refactor!: split context menu by type

The old ContextMenu handlers are gone and now there is one context menu
handler type depending on whether it is a message menu or a user menu.
It makes easier to fetch the messages or users assigned to a context
menu interaction.

It is also split by type of interaction: guild or DM, and answers
appropiately using the same new API as the other interaction types.

Author: danirod

src/cmd/makibotctl.ts

@@ -3,7 +3,11 @@ import { RESTGetAPIApplicationGuildCommandsResult, Routes } from "discord-api-ty
 import path from "path";
 import * as yargs from "yargs";
 import Client from "../lib/http/client";
-import { CommandInteractionHandler, ContextMenuInteractionHandler } from "../lib/interaction";
+import {
+  CommandInteractionHandler,
+  MessageContextMenuInteractionHandler,
+  UserContextMenuInteractionHandler,
+} from "../lib/interaction";
 import { requireAllModules } from "../lib/utils/loader";
 
 const client = new Client();
@@ -45,7 +49,8 @@ makibotctl.command<{ app: string; local?: string }>(
 
     /* Compose the payloads for commands and menus. */
     const commandsDir = path.join(__dirname, "../interactions/commands");
-    const menusDir = path.join(__dirname, "../interactions/menus");
+    const messageMenusDir = path.join(__dirname, "../interactions/messagemenus");
+    const userMenusDir = path.join(__dirname, "../interactions/usermenus");
 
     const commandPayloads = requireAllModules(commandsDir).map((HandlerClass) => {
       if (typeof HandlerClass == "function") {
@@ -55,15 +60,23 @@ makibotctl.command<{ app: string; local?: string }>(
         return handler.build().toJSON();
       }
     });
-    const menuPayloads = requireAllModules(menusDir).map((HandlerClass) => {
+    const usermenuPayloads = requireAllModules(userMenusDir).map((HandlerClass) => {
       if (typeof HandlerClass == "function") {
         const handler = new (HandlerClass as {
-          new (): ContextMenuInteractionHandler;
+          new (): UserContextMenuInteractionHandler;
         })();
         return handler.build().toJSON();
       }
     });
-    const payloads = [...commandPayloads, ...menuPayloads];
+    const messagemenuPayloads = requireAllModules(messageMenusDir).map((HandlerClass) => {
+      if (typeof HandlerClass == "function") {
+        const handler = new (HandlerClass as {
+          new (): MessageContextMenuInteractionHandler;
+        })();
+        return handler.build().toJSON();
+      }
+    });
+    const payloads = [...commandPayloads, ...usermenuPayloads, ...messagemenuPayloads];
 
     /* Send the payloads. */
     const restClient = new REST({ version: "9" });

src/interactions/menus/viewkarma.ts

@@ -1,18 +1,19 @@
 import { tokenToDate } from "datetoken";
-import { ApplicationCommandType, Snowflake } from "discord-api-types/v9";
+import { Snowflake } from "discord-api-types/v9";
 import {
   ButtonInteraction,
   ContextMenuInteraction,
   InteractionReplyOptions,
   Message,
   MessageActionRow,
   MessageButton,
+  MessageContextMenuInteraction,
   MessageSelectMenu,
   MessageSelectOptionData,
   SelectMenuInteraction,
 } from "discord.js";
 import { ContextMenuCommandBuilder, userMention } from "@discordjs/builders";
-import type { ContextMenuInteractionHandler } from "../../lib/interaction";
+import type { MessageContextMenuInteractionHandler } from "../../lib/interaction";
 import Member from "../../lib/member";
 import { applyAction } from "../../lib/modlog/actions";
 import { notifyModlog } from "../../lib/modlog/notifications";
@@ -357,37 +358,21 @@ class ModerationRequest {
   }
 }
 
-export default class ModRequestCommand implements ContextMenuInteractionHandler {
+export default class ModRequestCommand implements MessageContextMenuInteractionHandler {
   name = "Aplicar o pedir moderación";
 
   build() {
     return new ContextMenuCommandBuilder().setName("Aplicar o pedir moderación").setType(3);
   }
 
-  async handle(event: ContextMenuInteraction): Promise<void> {
-    const parent = await event.deferReply({ ephemeral: true, fetchReply: true });
-    if (event.inGuild()) {
-      return this.handleGuild(event, parent.id);
-    }
-    const toast = createToast({
-      title: "Este comando no puede usarse fuera de un servidor",
-      severity: "error",
-    });
-    await event.editReply({
-      embeds: [toast],
-    });
-  }
+  async handleGuild(interaction: MessageContextMenuInteraction): Promise<void> {
+    const parent = await interaction.deferReply({ ephemeral: true, fetchReply: true });
+    const parentId = parent.id;
 
-  private async handleGuild(
-    interaction: ContextMenuInteraction,
-    parentId: Snowflake
-  ): Promise<void> {
     /* I'm only extracting the parameters here to avoid promises. */
     const server = new Server(interaction.guild);
     const reporter = await server.member(interaction.user);
-    const message = await interaction.channel.messages.fetch(
-      interaction.options.get("message").message.id
-    );
+    const message = await interaction.channel.messages.fetch(interaction.targetMessage.id);
     const target = await server.member(message.author.id);
 
     const prompt = new ModerationRequest({ parentId, interaction, message, reporter, target });

src/interactions/menus/mod.ts renamed to src/interactions/messagemenus/mod.ts

@@ -0,0 +1,16 @@
+import { ContextMenuCommandBuilder } from "@discordjs/builders";
+import { UserContextMenuInteraction } from "discord.js";
+import type { UserContextMenuInteractionHandler } from "../../lib/interaction";
+import { handleKarmaInteraction } from "../../lib/karma/interaction";
+
+export default class ViewKarmaCommand implements UserContextMenuInteractionHandler {
+  name = "Ver karma";
+
+  build() {
+    return new ContextMenuCommandBuilder().setName("Ver karma").setType(2);
+  }
+
+  async handleGuild(event: UserContextMenuInteraction): Promise<void> {
+    return handleKarmaInteraction(event, event.targetUser.id);
+  }
+}

src/interactions/usermenus/viewkarma.ts

@@ -6,8 +6,9 @@ import {
 import type {
   ButtonInteraction,
   CommandInteraction,
-  ContextMenuInteraction,
   Interaction,
+  MessageContextMenuInteraction,
+  UserContextMenuInteraction,
 } from "discord.js";
 import path from "path";
 import type Makibot from "../Makibot";
@@ -49,8 +50,23 @@ export interface CommandInteractionHandler extends BaseInteractionHandler {
     | Omit<SlashCommandBuilder, "addSubcommand" | "addSubcommandGroup">;
 }
 
-export interface ContextMenuInteractionHandler extends BaseInteractionHandler {
-  handle(event: ContextMenuInteraction): Promise<void>;
+export interface UserContextMenuInteractionHandler extends BaseInteractionHandler {
+  /** Handle the command when sent to a guild. */
+  handleGuild?: (event: UserContextMenuInteraction) => Promise<void>;
+
+  /** Handle the command when sent to a DM. */
+  handleDM?: (event: UserContextMenuInteraction) => Promise<void>;
+
+  build(): ContextMenuCommandBuilder;
+}
+
+export interface MessageContextMenuInteractionHandler extends BaseInteractionHandler {
+  /** Handle the command when sent to a guild. */
+  handleGuild?: (event: MessageContextMenuInteraction) => Promise<void>;
+
+  /** Handle the command when sent to a DM. */
+  handleDM?: (event: MessageContextMenuInteraction) => Promise<void>;
+
   build(): ContextMenuCommandBuilder;
 }
 
@@ -75,12 +91,14 @@ function loadInteractions<T extends BaseInteractionHandler>(path: string): { [k:
 
 export class InteractionManager {
   private commands: Index<CommandInteractionHandler>;
-  private menus: Index<ContextMenuInteractionHandler>;
+  private usermenus: Index<UserContextMenuInteractionHandler>;
+  private messagemenus: Index<MessageContextMenuInteractionHandler>;
   private buttons: Index<ButtonInteractionHandler>;
 
   constructor(readonly root: string, private readonly client: Makibot) {
     this.commands = loadInteractions(path.join(root, "commands"));
-    this.menus = loadInteractions(path.join(root, "menus"));
+    this.usermenus = loadInteractions(path.join(root, "usermenus"));
+    this.messagemenus = loadInteractions(path.join(root, "messagemenus"));
     this.buttons = loadInteractions(path.join(root, "buttons"));
     client.on("interactionCreate", this.handleInteraction.bind(this));
   }
@@ -90,7 +108,11 @@ export class InteractionManager {
       await this.handleCommandInteraction(interaction);
     }
     if (interaction.isContextMenu()) {
-      await this.handleContextMenuInteraction(interaction);
+      if (interaction.isUserContextMenu()) {
+        await this.handleUserContextMenuInteraction(interaction);
+      } else if (interaction.isMessageContextMenu()) {
+        await this.handleMessageContextMenuInteraction(interaction);
+      }
     }
     if (interaction.isButton()) {
       await this.handleButtonInteraction(interaction);
@@ -132,10 +154,77 @@ export class InteractionManager {
     }
   }
 
-  private async handleContextMenuInteraction(interaction: ContextMenuInteraction): Promise<void> {
-    const handler = this.menus[interaction.commandName];
+  private async handleUserContextMenuInteraction(
+    interaction: UserContextMenuInteraction
+  ): Promise<void> {
+    const handler = this.usermenus[interaction.commandName];
+    if (handler) {
+      if (interaction.inGuild()) {
+        if (handler.handleGuild) {
+          await handler.handleGuild(interaction);
+        } else {
+          const toast = createToast({
+            title: "Menú no apto en una guild",
+            description: "Este menú no se puede pulsar en una guild",
+            severity: "error",
+          });
+          await interaction.reply({
+            embeds: [toast],
+            ephemeral: true,
+          });
+        }
+      } else {
+        if (handler.handleDM) {
+          await handler.handleDM(interaction);
+        } else {
+          const toast = createToast({
+            title: "Menú no apto fuera de una guild",
+            description: "Este menú no se puede pulsar fuera de una guild",
+            severity: "error",
+          });
+          await interaction.reply({
+            embeds: [toast],
+            ephemeral: true,
+          });
+        }
+      }
+    }
+  }
+
+  private async handleMessageContextMenuInteraction(
+    interaction: MessageContextMenuInteraction
+  ): Promise<void> {
+    const handler = this.messagemenus[interaction.commandName];
     if (handler) {
-      await handler.handle(interaction);
+      if (interaction.inGuild()) {
+        if (handler.handleGuild) {
+          await handler.handleGuild(interaction);
+        } else {
+          const toast = createToast({
+            title: "Menú no apto en una guild",
+            description: "Este menú no se puede pulsar en una guild",
+            severity: "error",
+          });
+          await interaction.reply({
+            embeds: [toast],
+            ephemeral: true,
+          });
+        }
+      } else {
+        if (handler.handleDM) {
+          await handler.handleDM(interaction);
+        } else {
+          const toast = createToast({
+            title: "Menú no apto fuera de una guild",
+            description: "Este menú no se puede pulsar fuera de una guild",
+            severity: "error",
+          });
+          await interaction.reply({
+            embeds: [toast],
+            ephemeral: true,
+          });
+        }
+      }
     }
   }