feat: make modules isolated using creation function

.env.example

@@ -5,7 +5,7 @@ DISCORD_TOKEN=
 REDIS_URL=
 
 # CHANNELS
-COOL_LINKS_CHANNEL_ID=
+COOL_LINKS_MANAGEMENT_CHANNEL_ID=
+COOL_LINKS_MANAGEMENT_PAGE_SUMMARIZER_BASE_URL=
 
-# API
-PAGE_SUMMARIZER_BASE_URL=
+PATTERN_REPLACE_EXCLUDED_CHANNEL_ID=

package.json

@@ -16,12 +16,13 @@
   "dependencies": {
     "@keyv/redis": "2.7.0",
     "cheerio": "1.0.0-rc.12",
+    "constant-case": "3.0.4",
     "cron": "2.4.3",
     "discord.js": "14.13.0",
-    "env-var": "7.4.1",
     "keyv": "4.5.3",
     "open-graph-scraper": "6.2.2",
-    "param-case": "3.0.4"
+    "param-case": "3.0.4",
+    "zod": "3.22.2"
   },
   "devDependencies": {
     "@types/node": "20.6.2",

src/__tests__/summarize-cool-pages.spec.ts

@@ -30,10 +30,6 @@ type SummarizeCoolPagesFixture = ReturnType<typeof createSummarizeCoolPagesFixtu
 describe('Feature: summarize cool pages', () => {
   let fixture: SummarizeCoolPagesFixture;
   beforeEach(() => {
-    // config is mocked to avoid to call the third party API and to avoid to handle env-var
-    vi.mock('../config', async () => ({
-      config: (await import('./mocks/config.mock')).default,
-    }));
     // useless atm but will be useful when we will have to reset the fixture
     fixture = createSummarizeCoolPagesFixture();
   });

src/core/cache.ts

@@ -2,8 +2,8 @@ import '@keyv/redis';
 
 import Keyv from 'keyv';
 
-import { config } from '../config';
 import type { Frequency } from '../modules/recurringMessage/recurringMessage.helpers';
+import { env } from './env';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 interface CacheGet<Entries extends Record<string, any>> {
@@ -28,7 +28,7 @@ interface CacheEntries {
 }
 
 class CacheImpl implements Cache<CacheEntries> {
-  private readonly backend = new Keyv(config.redis.url);
+  private readonly backend = new Keyv(env.redisUrl);
 
   public get<Key extends keyof CacheEntries>(key: Key): Promise<CacheEntries[Key] | undefined>;
   public get<Key extends keyof CacheEntries>(

src/core/createEnvForModule.ts

@@ -0,0 +1,34 @@
+import { constantCase } from 'constant-case';
+
+import type { CreatedModule, ModuleFactory } from './createModule';
+
+const createEnvForModule = (constantName: string) =>
+  Object.entries(process.env)
+    .filter(([key]) => key.startsWith(constantName))
+    .reduce<Record<string, string>>((acc, [key, value]) => {
+      const envKey = key.replace(`${constantName}_`, '');
+
+      if (value === undefined) {
+        return acc;
+      }
+
+      acc[envKey] = value;
+
+      return acc;
+    }, {});
+
+export const createAllModules = async (
+  modules: Record<string, ModuleFactory>,
+): Promise<CreatedModule[]> => {
+  const createdModules: CreatedModule[] = [];
+
+  for (const [name, factory] of Object.entries(modules)) {
+    const moduleConstantName = constantCase(name);
+    const moduleEnv = createEnvForModule(moduleConstantName);
+    const module = await factory({ env: moduleEnv });
+
+    createdModules.push(module);
+  }
+
+  return createdModules;
+};

src/core/createModule.ts

@@ -0,0 +1,58 @@
+import type { ClientEvents, ClientOptions } from 'discord.js';
+import type { ZodTypeAny } from 'zod';
+import { z } from 'zod';
+
+import type { BotCommand, EventHandler } from '../types/bot';
+
+type InferredZodShape<Shape extends Record<string, ZodTypeAny>> = {
+  [K in keyof Shape]: Shape[K]['_type'];
+};
+
+interface Context<Env extends Record<string, ZodTypeAny>> {
+  env: InferredZodShape<Env>;
+}
+
+type ModuleFunction<Env extends Record<string, ZodTypeAny>, ReturnType> = (
+  context: Context<Env>,
+) => ReturnType;
+
+type EventHandlers = {
+  [K in keyof ClientEvents]?: EventHandler<K>;
+};
+
+type BotModule<Env extends Record<string, ZodTypeAny>> = {
+  env?: Env;
+  intents?: ClientOptions['intents'];
+  slashCommands?: ModuleFunction<Env, Array<BotCommand>>;
+  eventHandlers?: ModuleFunction<Env, EventHandlers>;
+};
+
+interface CreatedModuleInput {
+  env: unknown;
+}
+
+export interface CreatedModule {
+  intents: ClientOptions['intents'];
+  slashCommands: Array<BotCommand>;
+  eventHandlers: EventHandlers;
+}
+
+export type ModuleFactory = (input: CreatedModuleInput) => Promise<CreatedModule>;
+
+export const createModule = <Env extends Record<string, ZodTypeAny>>(
+  module: BotModule<Env>,
+): ModuleFactory => {
+  return async (input) => {
+    const env = await z.object(module.env ?? ({} as Env)).parseAsync(input.env);
+
+    const context = {
+      env,
+    };
+
+    return {
+      intents: module.intents ?? [],
+      slashCommands: module.slashCommands?.(context) ?? [],
+      eventHandlers: module.eventHandlers?.(context) ?? {},
+    };
+  };
+};

src/core/env.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+const envShape = z
+  .object({
+    DISCORD_TOKEN: z.string().nonempty(),
+    REDIS_URL: z.string().url(),
+  })
+  .transform((object) => ({
+    discordToken: object.DISCORD_TOKEN,
+    redisUrl: object.REDIS_URL,
+  }));
+
+export const env = envShape.parse(process.env);

src/core/getIntentsFromModules.ts

@@ -1,6 +1,6 @@
-import type { BotModule } from '../types/bot';
+import type { CreatedModule } from './createModule';
 
-export const getIntentsFromModules = (modules: Record<string, BotModule>) => {
-  const intents = Object.values(modules).flatMap((module) => module.intents ?? []);
+export const getIntentsFromModules = (modules: CreatedModule[]) => {
+  const intents = modules.flatMap((module) => module.intents ?? []);
   return [...new Set(intents)] as const;
 };

src/core/loadModules.ts

@@ -1,15 +1,19 @@
 import { type Client } from 'discord.js';
 
-import type { BotModule } from '../types/bot';
 import { checkUniqueSlashCommandNames } from './checkUniqueSlashCommandNames';
+import type { CreatedModule } from './createModule';
+import { env } from './env';
 import { pushCommands, routeCommands } from './loaderCommands';
 import { routeHandlers } from './routeHandlers';
 
 export const loadModules = async (
   client: Client<true>,
-  modulesToLoad: Record<string, BotModule>,
+  modules: CreatedModule[],
 ): Promise<void> => {
-  const botCommands = Object.values(modulesToLoad).flatMap((module) => module.slashCommands ?? []);
+  await Promise.allSettled(modules.map((module) => module.eventHandlers?.ready?.(client)));
+
+  const botCommands = modules.flatMap((module) => module.slashCommands ?? []);
+
   checkUniqueSlashCommandNames(botCommands);
   routeCommands(client, botCommands);
 
@@ -19,11 +23,13 @@ export const loadModules = async (
   const { guilds } = client;
 
   for (const guild of guilds.cache.values()) {
-    await pushCommands(
-      botCommands.map((command) => command.schema),
-      clientId,
-      guild.id,
-    );
+    await pushCommands({
+      commands: botCommands.map((command) => command.schema),
+      clientId: clientId,
+      guildId: guild.id,
+      discordToken: env.discordToken,
+    });
   }
-  routeHandlers(client, modulesToLoad);
+
+  routeHandlers(client, modules);
 };

src/core/loaderCommands.ts

@@ -5,18 +5,23 @@ import {
   Routes,
 } from 'discord.js';
 
-import { config } from '../config';
 import type { BotCommand } from '../types/bot';
 import { deleteExistingCommands } from './deleteExistingCommands';
 
-const { discord } = config;
+interface PushCommandsOptions {
+  commands: RESTPostAPIChatInputApplicationCommandsJSONBody[];
+  clientId: string;
+  guildId: string;
+  discordToken: string;
+}
 
-export const pushCommands = async (
-  commands: RESTPostAPIChatInputApplicationCommandsJSONBody[],
-  clientId: string,
-  guildId: string,
-) => {
-  const rest = new REST({ version: '10' }).setToken(discord.token);
+export const pushCommands = async ({
+  commands,
+  clientId,
+  guildId,
+  discordToken,
+}: PushCommandsOptions) => {
+  const rest = new REST({ version: '10' }).setToken(discordToken);
   await deleteExistingCommands(rest, clientId, guildId);
   await rest.put(Routes.applicationGuildCommands(clientId, guildId), {
     body: commands,