meocord 3.2.0 → 3.2.1

package/dist/cjs/core/index.cjs

@@ -26,23 +26,44 @@ const createErrorEmbed = (description)=>{
     return embed;
 };
 
+/** What Discord assumes a command body is when it carries no type of its own. */ const DEFAULT_APPLICATION_COMMAND_TYPE = discord_js.ApplicationCommandType.ChatInput;
 /**
- * The name a builder registers under, which is what Discord deduplicates on.
+ * The body a builder registers, which is what Discord sees.
  *
- * Read from the built payload rather than from the `@Command` argument: a builder is
- * free to name the command something other than the string it was handed, and it is
- * the payload Discord sees.
- */ function commandNameOf(builder) {
+ * Read from the built payload rather than from the `@Command` arguments: a builder is
+ * free to describe the command differently from the strings it was handed.
+ */ function payloadOf(builder) {
     try {
-        const json = typeof builder.toJSON === 'function' ? builder.toJSON() : builder;
-        return typeof json?.name === 'string' ? json.name : undefined;
+        return typeof builder.toJSON === 'function' ? builder.toJSON() : builder;
     } catch  {
         // A builder missing a required field throws from toJSON. Surfacing that is the
         // registration call's job, where it is reported against the command Discord
         // rejected -- deduplication should not be what turns it into a startup crash.
-        return undefined;
+        return {};
     }
 }
+/** The name a builder registers under. */ function commandNameOf(builder) {
+    const { name } = payloadOf(builder);
+    return typeof name === 'string' ? name : undefined;
+}
+/**
+ * The application command type a builder registers as.
+ *
+ * A slash builder may leave the field out, so an absent type is read as the chat input
+ * one Discord would infer — which keeps untyped slash builders colliding with each
+ * other rather than each claiming a key of its own.
+ */ function commandTypeOf(builder) {
+    const { type } = payloadOf(builder);
+    return typeof type === 'number' ? type : DEFAULT_APPLICATION_COMMAND_TYPE;
+}
+/**
+ * The identity Discord gives a command.
+ *
+ * The numeric type leads, so the two halves can never be read apart wrongly: everything
+ * before the first separator is the type, everything after it is the name.
+ */ function registrationKey(builder, fallbackName) {
+    return `${commandTypeOf(builder)}:${commandNameOf(builder) ?? fallbackName}`;
+}
 class MeoCordApp {
     /**
    * Runs an event handler so a failure inside it cannot take the process down.
@@ -109,11 +130,13 @@ class MeoCordApp {
         }
     }
     async registerCommands() {
-        // Keyed by registered name: a command whose subcommands live in separate methods
-        // declares the same name more than once, and sending its builder twice makes
-        // Discord reject the whole payload. The first builder wins, and a second one that
-        // is not the same object is reported rather than silently dropped.
-        const buildersByName = new Map();
+        // Keyed by type and name together, because that pair is what Discord treats as one
+        // command: a user context menu and a message context menu are free to share a name,
+        // and keying on the name alone would drop one of them from the payload. Within a
+        // single type the name is unique, so a command whose subcommands live in separate
+        // methods still contributes its builder once — sending it twice makes Discord
+        // reject the whole payload.
+        const buildersByCommand = new Map();
         for (const controllerClass of this.controllerClasses){
             const instance = this.getInstance(controllerClass);
             const commandMap = controller_decorator.getCommandMap(instance);
@@ -122,18 +145,18 @@ class MeoCordApp {
                 if (!Array.isArray(commandMetadataArray)) continue;
                 for (const { builder, type } of commandMetadataArray){
                     if (!(type in enum_index.CommandType) || !builder) continue;
-                    const registeredName = commandNameOf(builder) ?? commandName;
-                    const existing = buildersByName.get(registeredName);
+                    const key = registrationKey(builder, commandName);
+                    const existing = buildersByCommand.get(key);
                     if (existing === undefined) {
-                        buildersByName.set(registeredName, builder);
+                        buildersByCommand.set(key, builder);
                     } else if (existing !== builder) {
-                        this.logger.warn(`Command "${registeredName}" is built more than once; only the first builder is registered. ` + `Declare the builder on one @Command and give the others the plain CommandType.`);
+                        this.logger.warn(`Command "${commandNameOf(builder) ?? commandName}" is built more than once for the same ` + `application command type; only the first builder is registered. Two builders of one type ` + `cannot both own a name, so declare the builder on a single @Command and give the others ` + `the plain CommandType.`);
                     }
                 }
             }
         }
         const builders = [
-            ...buildersByName.values()
+            ...buildersByCommand.values()
         ];
         try {
             if (this.bot.application) {

package/dist/esm/core/meocord.app.js

@@ -1,4 +1,4 @@
-import { SlashCommandBuilder, MessageFlagsBitField } from 'discord.js';
+import { ApplicationCommandType, SlashCommandBuilder, MessageFlagsBitField } from 'discord.js';
 import { Logger } from '../common/logger.js';
 import '../common/theme.js';
 import { getCommandMap, findAmbiguousRoutes, PARAM_SEPARATOR, getAutocompleteHandlers, getMessageHandlers, getReactionHandlers } from '../decorator/controller.decorator.js';
@@ -8,23 +8,44 @@ import { describeInteraction, hasCustomId, matchesCommandType, resolveCommandPat
 import { ReactionHandlerAction, CommandType } from '../enum/controller.enum.js';
 import CliTable3 from 'cli-table3';
 
+/** What Discord assumes a command body is when it carries no type of its own. */ const DEFAULT_APPLICATION_COMMAND_TYPE = ApplicationCommandType.ChatInput;
 /**
- * The name a builder registers under, which is what Discord deduplicates on.
+ * The body a builder registers, which is what Discord sees.
  *
- * Read from the built payload rather than from the `@Command` argument: a builder is
- * free to name the command something other than the string it was handed, and it is
- * the payload Discord sees.
- */ function commandNameOf(builder) {
+ * Read from the built payload rather than from the `@Command` arguments: a builder is
+ * free to describe the command differently from the strings it was handed.
+ */ function payloadOf(builder) {
     try {
-        const json = typeof builder.toJSON === 'function' ? builder.toJSON() : builder;
-        return typeof json?.name === 'string' ? json.name : undefined;
+        return typeof builder.toJSON === 'function' ? builder.toJSON() : builder;
     } catch  {
         // A builder missing a required field throws from toJSON. Surfacing that is the
         // registration call's job, where it is reported against the command Discord
         // rejected -- deduplication should not be what turns it into a startup crash.
-        return undefined;
+        return {};
     }
 }
+/** The name a builder registers under. */ function commandNameOf(builder) {
+    const { name } = payloadOf(builder);
+    return typeof name === 'string' ? name : undefined;
+}
+/**
+ * The application command type a builder registers as.
+ *
+ * A slash builder may leave the field out, so an absent type is read as the chat input
+ * one Discord would infer — which keeps untyped slash builders colliding with each
+ * other rather than each claiming a key of its own.
+ */ function commandTypeOf(builder) {
+    const { type } = payloadOf(builder);
+    return typeof type === 'number' ? type : DEFAULT_APPLICATION_COMMAND_TYPE;
+}
+/**
+ * The identity Discord gives a command.
+ *
+ * The numeric type leads, so the two halves can never be read apart wrongly: everything
+ * before the first separator is the type, everything after it is the name.
+ */ function registrationKey(builder, fallbackName) {
+    return `${commandTypeOf(builder)}:${commandNameOf(builder) ?? fallbackName}`;
+}
 class MeoCordApp {
     /**
    * Runs an event handler so a failure inside it cannot take the process down.
@@ -91,11 +112,13 @@ class MeoCordApp {
         }
     }
     async registerCommands() {
-        // Keyed by registered name: a command whose subcommands live in separate methods
-        // declares the same name more than once, and sending its builder twice makes
-        // Discord reject the whole payload. The first builder wins, and a second one that
-        // is not the same object is reported rather than silently dropped.
-        const buildersByName = new Map();
+        // Keyed by type and name together, because that pair is what Discord treats as one
+        // command: a user context menu and a message context menu are free to share a name,
+        // and keying on the name alone would drop one of them from the payload. Within a
+        // single type the name is unique, so a command whose subcommands live in separate
+        // methods still contributes its builder once — sending it twice makes Discord
+        // reject the whole payload.
+        const buildersByCommand = new Map();
         for (const controllerClass of this.controllerClasses){
             const instance = this.getInstance(controllerClass);
             const commandMap = getCommandMap(instance);
@@ -104,18 +127,18 @@ class MeoCordApp {
                 if (!Array.isArray(commandMetadataArray)) continue;
                 for (const { builder, type } of commandMetadataArray){
                     if (!(type in CommandType) || !builder) continue;
-                    const registeredName = commandNameOf(builder) ?? commandName;
-                    const existing = buildersByName.get(registeredName);
+                    const key = registrationKey(builder, commandName);
+                    const existing = buildersByCommand.get(key);
                     if (existing === undefined) {
-                        buildersByName.set(registeredName, builder);
+                        buildersByCommand.set(key, builder);
                     } else if (existing !== builder) {
-                        this.logger.warn(`Command "${registeredName}" is built more than once; only the first builder is registered. ` + `Declare the builder on one @Command and give the others the plain CommandType.`);
+                        this.logger.warn(`Command "${commandNameOf(builder) ?? commandName}" is built more than once for the same ` + `application command type; only the first builder is registered. Two builders of one type ` + `cannot both own a name, so declare the builder on a single @Command and give the others ` + `the plain CommandType.`);
                     }
                 }
             }
         }
         const builders = [
-            ...buildersByName.values()
+            ...buildersByCommand.values()
         ];
         try {
             if (this.bot.application) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "meocord",
   "description": "Decorator-based Discord bot framework built on discord.js. Brings NestJS-style controllers, dependency injection, guards, and testing utilities to bot development — with a full CLI and TypeScript-first design.",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "type": "module",
   "engines": {
     "node": ">=22"