refactor: modularize commands and handlers (#48)

Co-authored-by: Peïo Thibault <[email protected]>

src/__tests__/resolve-catch.helper.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { resolveCatch } from '../helpers/resolve-catch.helper';
+import { resolveCatch } from '../helpers/resolveCatch.helper';
 
 describe('resolve-catch.helper', () => {
   it('should throw an error if the promise is rejected with an error', async () => {

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

@@ -5,7 +5,7 @@ import {
   isPageSummarizeSuccessData,
   NoContentFoundSummaryError,
   parseHtmlSummarized,
-} from '../summarize-cool-pages';
+} from '../modules/coolLinksManagement/summarizeCoolPages';
 const createSummarizeCoolPagesFixture = () => {
   return {
     // from https://react.dev/learn/you-might-not-need-an-effect

src/core/checkUniqueSlashCommandNames.ts

@@ -0,0 +1,11 @@
+import type { BotModule } from '../types/bot';
+
+export const checkUniqueSlashCommandNames = (modulesToLoad: Record<string, BotModule>) => {
+  const slashCommandNames = Object.values(modulesToLoad)
+    .flatMap((module) => module.slashCommands ?? [])
+    .map((command) => command.schema.name);
+  const uniqueSlashCommandNames = new Set(slashCommandNames);
+  if (uniqueSlashCommandNames.size !== slashCommandNames.length) {
+    throw new Error('Found duplicate slash command names');
+  }
+};

src/delete-existing-commands.ts → src/core/deleteExistingCommands.ts

@@ -1,6 +1,6 @@
 import { REST, Routes } from 'discord.js';
 
-import { config } from './config';
+import { config } from '../config';
 
 export const deleteExistingCommands = async (
   rest: REST,

src/core/loadModules.ts

@@ -0,0 +1,19 @@
+import { type Client } from 'discord.js';
+
+import type { BotModule } from '../types/bot';
+import { checkUniqueSlashCommandNames } from './checkUniqueSlashCommandNames';
+import { pushCommands, routeCommands } from './loaderCommands';
+import { routeHandlers } from './routeHandlers';
+
+export const loadModules = async (
+  client: Client<true>,
+  modulesToLoad: Record<string, BotModule>,
+): Promise<void> => {
+  const botCommands = Object.values(modulesToLoad).flatMap((module) => module.slashCommands ?? []);
+
+  checkUniqueSlashCommandNames(modulesToLoad);
+  routeCommands(client, botCommands);
+  await pushCommands(botCommands.map((command) => command.schema));
+
+  routeHandlers(client, modulesToLoad);
+};

src/core/loaderCommands.ts

@@ -0,0 +1,56 @@
+import {
+  Client,
+  REST,
+  type RESTPostAPIChatInputApplicationCommandsJSONBody,
+  Routes,
+} from 'discord.js';
+
+import { config } from '../config';
+import type { BotCommand } from '../types/bot';
+import { deleteExistingCommands } from './deleteExistingCommands';
+
+const { discord } = config;
+
+export const pushCommands = async (commands: RESTPostAPIChatInputApplicationCommandsJSONBody[]) => {
+  const rest = new REST({ version: '10' }).setToken(discord.token);
+  await deleteExistingCommands(rest, discord);
+  await rest.put(Routes.applicationGuildCommands(discord.clientId, discord.guildId), {
+    body: commands,
+  });
+};
+
+export const routeCommands = (client: Client<true>, botCommands: BotCommand[]) =>
+  client.on('interactionCreate', async (interaction) => {
+    if (!interaction.inGuild() || !interaction.isChatInputCommand()) {
+      return;
+    }
+
+    const command = botCommands.find((command) => command.schema.name === interaction.commandName);
+
+    if (!command) {
+      await interaction.reply({
+        content: `Command not found ${interaction.commandName}`,
+        ephemeral: true,
+      });
+      return;
+    }
+
+    if (typeof command.handler === 'function') {
+      await command.handler(interaction);
+      return;
+    }
+
+    const subCommand = command.handler[interaction.options.getSubcommand()];
+
+    if (!subCommand) {
+      await interaction.reply({
+        content: `Subcommand not found ${
+          interaction.commandName
+        } ${interaction.options.getSubcommand()}`,
+        ephemeral: true,
+      });
+      return;
+    }
+
+    await subCommand(interaction);
+  });

src/core/routeHandlers.ts

@@ -0,0 +1,21 @@
+import type { Client, ClientEvents } from 'discord.js';
+
+import type { BotModule, EventHandler } from '../types/bot';
+
+export const routeHandlers = (client: Client<true>, modulesToLoad: Record<string, BotModule>) => {
+  const eventNames = Object.values(modulesToLoad).flatMap(
+    (module) => Object.keys(module.eventHandlers ?? {}) as (keyof ClientEvents)[],
+  );
+  const uniqueEventNames = [...new Set(eventNames)];
+
+  uniqueEventNames.forEach((eventName) => {
+    const eventHandlersToCall = Object.values(modulesToLoad)
+      .map((module) => module.eventHandlers?.[eventName])
+      .filter((e): e is EventHandler => Boolean(e));
+
+    client.on(eventName, async (...args) => {
+      const handlersPromises = eventHandlersToCall.map(async (handler) => handler(...args));
+      await Promise.allSettled(handlersPromises);
+    });
+  });
+};