feat: guild commands

Author: twlite

apps/test-bot/src/app/commands/server/command.ts

@@ -0,0 +1,15 @@
+import type { CommandData, SlashCommand, MessageCommand } from 'commandkit';
+
+export const command: CommandData = {
+  name: 'server',
+  description: 'server command',
+  guilds: [process.env.DEV_GUILD_ID],
+};
+
+export const chatInput: SlashCommand = async (ctx) => {
+  await ctx.interaction.reply('Hello from server!');
+};
+
+export const message: MessageCommand = async (ctx) => {
+  await ctx.message.reply('Hello from server!');
+};

packages/commandkit/src/app/command-handler/AppCommandHandler.ts

@@ -32,6 +32,7 @@ interface AppCommandMiddleware {
 interface LoadedCommand {
   command: ParsedCommand;
   data: AppCommand;
+  guilds?: string[];
 }
 
 interface LoadedMiddleware {
@@ -99,6 +100,13 @@ export class AppCommandHandler {
 
           if (!loadedCommand) return null;
 
+          if (
+            source.guildId &&
+            loadedCommand.guilds?.length &&
+            !loadedCommand.guilds.includes(source.guildId!)
+          )
+            return null;
+
           const json =
             'toJSON' in loadedCommand.data.command
               ? loadedCommand.data.command.toJSON()
@@ -226,6 +234,7 @@ export class AppCommandHandler {
 
       this.loadedCommands.set(name, {
         command,
+        guilds: data.guilds,
         data: {
           ...data,
           command: localizedCommand,

packages/commandkit/src/legacy/handlers/command-handler/functions/loadCommandsWithRest.ts

@@ -81,15 +81,19 @@ async function handleLoading(
   type?: ReloadOptions,
 ) {
   commands = commands.filter((cmd) => !cmd.options?.deleted);
-  const devOnlyCommands = commands.filter((cmd) => cmd.options?.devOnly);
-  const globalCommands = commands.filter((cmd) => !cmd.options?.devOnly);
+  const devOnlyCommands = commands.filter(
+    (cmd) => cmd.options?.devOnly || cmd.data?.guilds?.length,
+  );
+  const globalCommands = commands.filter(
+    (cmd) => !cmd.options?.devOnly && !cmd.data?.guilds?.length,
+  );
 
   if (type === 'dev') {
-    await loadDevCommands(client, devOnlyCommands, devGuildIds, reloading);
+    await loadGuildCommands(client, devOnlyCommands, devGuildIds, reloading);
   } else if (type === 'global') {
     await loadGlobalCommands(client, globalCommands, reloading);
   } else {
-    await loadDevCommands(client, devOnlyCommands, devGuildIds, reloading);
+    await loadGuildCommands(client, devOnlyCommands, devGuildIds, reloading);
     await loadGlobalCommands(client, globalCommands, reloading);
   }
 }
@@ -130,6 +134,25 @@ async function loadGlobalCommands(
   );
 }
 
+async function loadGuildCommands(
+  client: Client<true>,
+  commands: CommandFileObject[],
+  guildIds: string[],
+  reloading?: boolean,
+) {
+  const guildDefined = commands.filter((cmd) => cmd.data.guilds?.length);
+  const guildNotDefined = commands.filter((cmd) => !cmd.data.guilds?.length);
+
+  await loadDevCommands(client, guildNotDefined, guildIds, reloading);
+  await loadDevCommands(
+    client,
+    guildDefined,
+    guildDefined.flatMap((c) => c.data.guilds).filter((c) => c !== undefined),
+    reloading,
+    'guild',
+  );
+}
+
 /**
  * Load commands for dev guilds.
  * @param client - The discord.js client instance.
@@ -142,8 +165,12 @@ async function loadDevCommands(
   commands: CommandFileObject[],
   guildIds: string[],
   reloading?: boolean,
+  type = 'developer',
 ) {
-  const requestBody = commands.map((cmd) => cmd.data);
+  const requestBody = commands.map((cmd) => {
+    delete cmd.data.guilds;
+    return cmd.data;
+  });
 
   for (const guildId of guildIds) {
     const targetGuild =
@@ -166,7 +193,7 @@ async function loadDevCommands(
           colors.red(
             `Error ${
               reloading ? 'reloading' : 'loading'
-            } developer application commands in guild "${
+            } ${type || 'developer'} application commands in guild "${
               targetGuild?.name || guildId
             }".\n`,
           ),
@@ -178,7 +205,7 @@ async function loadDevCommands(
       colors.green(
         `${reloading ? 'Reloaded' : 'Loaded'} ${
           requestBody.length
-        } developer commands in guild "${targetGuild.name}".`,
+        } ${type || 'developer'} commands in guild "${targetGuild.name}".`,
       ),
     );
   }

packages/commandkit/src/legacy/handlers/command-handler/functions/registerCommands.ts

@@ -59,15 +59,19 @@ async function handleRegistration(
   devGuildIds: string[],
   type?: ReloadOptions,
 ) {
-  const devOnlyCommands = commands.filter((cmd) => cmd.options?.devOnly);
-  const globalCommands = commands.filter((cmd) => !cmd.options?.devOnly);
+  const devOnlyCommands = commands.filter(
+    (cmd) => cmd.options?.devOnly || cmd.data?.guilds?.length,
+  );
+  const globalCommands = commands.filter(
+    (cmd) => !cmd.options?.devOnly && !cmd.data?.guilds?.length,
+  );
 
   if (type === 'dev') {
-    await registerDevCommands(client, devOnlyCommands, devGuildIds);
+    await registerGuildCommands(client, devOnlyCommands, devGuildIds);
   } else if (type === 'global') {
     await registerGlobalCommands(client, globalCommands);
   } else {
-    await registerDevCommands(client, devOnlyCommands, devGuildIds);
+    await registerGuildCommands(client, devOnlyCommands, devGuildIds);
     await registerGlobalCommands(client, globalCommands);
   }
 }
@@ -255,16 +259,17 @@ async function registerDevCommands(
       // <!-- Register guild command -->
       if (targetCommand) continue;
 
-      await guildCommands
-        .create(command.data as ApplicationCommandDataResolvable)
-        .catch((error) => {
-          throw new Error(
-            colors.red(
-              `Failed to register command "${command.data.name}" in ${guildCommands.guild.name}.\n`,
-            ),
-            error,
-          );
-        });
+      delete command.data.guilds;
+      const commandData = command.data as ApplicationCommandDataResolvable;
+
+      await guildCommands.create(commandData).catch((error) => {
+        throw new Error(
+          colors.red(
+            `Failed to register command "${command.data.name}" in ${guildCommands.guild.name}.\n`,
+          ),
+          error,
+        );
+      });
 
       Logger.log(
         colors.green(
@@ -274,3 +279,19 @@ async function registerDevCommands(
     }
   }
 }
+
+async function registerGuildCommands(
+  client: Client<true>,
+  commands: CommandFileObject[],
+  devGuildIds: string[],
+) {
+  const guildCommands = commands.filter((c) => c.data.guilds?.length);
+  const notGuildCommands = commands.filter((c) => c.options?.devOnly);
+
+  await registerDevCommands(client, notGuildCommands, devGuildIds);
+  await registerDevCommands(
+    client,
+    guildCommands,
+    guildCommands.flatMap((c) => c.data.guilds).filter((c) => c !== undefined),
+  );
+}

packages/commandkit/src/types.ts

@@ -258,7 +258,9 @@ export interface CommandOptions {
   [key: string]: any;
 }
 
-export type CommandData = RESTPostAPIApplicationCommandsJSONBody;
+export type CommandData = RESTPostAPIApplicationCommandsJSONBody & {
+  guilds?: string[];
+};
 
 export type CommandObject = {
   /**