@pikokr/command.ts 3.2.3 → 3.2.4-dev.535de3c

package/src/builtinModules/CommandHandler.ts

@@ -1,11 +1,23 @@
 import { BuiltInModule } from './BuiltInModule'
 import { Registry } from '../structures'
 import { listener } from '../listener'
-import { CommandInteraction, GuildMember, Interaction, Message, Role, User } from 'discord.js'
+import {
+  CommandInteraction,
+  GuildMember,
+  Interaction,
+  Message,
+  MessageComponentInteraction,
+  MessageContextMenuInteraction,
+  Role,
+  User,
+  UserContextMenuInteraction,
+} from 'discord.js'
 import { CommandClient } from '../structures'
 import { Command } from '../command'
-import { ArgumentConverterNotFound, ArgumentNotProvided, CommandCheckFailed, SlashArgumentConverterNotFound, SlashCommandCheckFailed } from '../error'
+import { ArgumentConverterNotFound, ArgumentNotProvided, CommandCheckFailed, SlashArgumentConverterNotFound, ApplicationCommandCheckFailed } from '../error'
 import { CommandNotFound } from '../error/CommandNotFound'
+import { SlashCommandGlobalCheckError } from '../error/checks/SlashCommandGlobalCheckError'
+import { MessageComponentHandler } from '../messageComponents/base'
 
 export class CommandHandler extends BuiltInModule {
   private readonly client: CommandClient
@@ -15,6 +27,7 @@ export class CommandHandler extends BuiltInModule {
     this.client = registry.client
   }
 
+  // region message command handler
   @listener('messageCreate')
   async message(msg: Message) {
     const error = (error: Error) => this.client.client.emit('commandError', error, msg)
@@ -48,19 +61,21 @@ export class CommandHandler extends BuiltInModule {
 
       let cmd: Command | null = null
 
+      const globalAliases = await this.client.options.command.globalAliases(command, msg)
+
       for (const c of this.registry.commands) {
-        if (c.name === command) {
+        const globalAliases2 = await this.client.options.command.globalAliases(c.name, msg)
+        const aliases = typeof c.aliases === 'function' ? await c.aliases(msg) : c.aliases
+        if ([...aliases, c.name].some((x) => x === command)) {
           cmd = c
           break
         }
-        if ((typeof c.aliases === 'function' ? await c.aliases(msg) : c.aliases).includes(command)) {
+        if (globalAliases.every((x, i) => globalAliases2[i] === x)) {
           cmd = c
           break
         }
       }
 
-      if (!cmd) return error(new CommandNotFound(command, msg, args))
-
       msg.data = {
         cts: this.client,
         command: cmd,
@@ -71,6 +86,8 @@ export class CommandHandler extends BuiltInModule {
         return
       }
 
+      if (!cmd) return error(new CommandNotFound(command, msg, args))
+
       const module = this.registry.modules.find((x) => x.commands.includes(cmd!))
 
       if (!module) return
@@ -125,31 +142,32 @@ export class CommandHandler extends BuiltInModule {
       return error(e)
     }
   }
+  // endregion
 
+  // region slash command handler
   private async command(i: CommandInteraction) {
-    const error = (error: Error) => this.client.client.emit('slashCommandError', error, i)
+    const error = (error: Error) => this.client.client.emit('applicationCommandError', error, i)
     try {
-      const cmd = this.registry.slashCommands.find((x) => x.commandBuilder.name === i.commandName)
+      const cmd = this.registry.applicationCommands.find((x) => x.command.type === 'CHAT_INPUT' && x.command.name === i.commandName)
 
-      const module = this.registry.modules.find((x) => x.slashCommands.includes(cmd!))
+      if (!cmd) return
+
+      const module = this.registry.modules.find((x) => x.applicationCommands.includes(cmd))
 
       if (!module) return
 
       const argList: any[] = []
 
-      if (!cmd)
-        return i.reply({
-          content: 'Unknown command.',
-          ephemeral: true,
-        })
-
       i.data = {
         cts: this.client,
         command: cmd,
       }
 
+      if (!(await this.client.options.slashCommands.check(i))) {
+        return error(new SlashCommandGlobalCheckError(i))
+      }
       for (const check of cmd.checks) {
-        if (!(await check(i))) return error(new SlashCommandCheckFailed(i, cmd))
+        if (!(await check(i))) return error(new ApplicationCommandCheckFailed(i, cmd))
       }
 
       for (let j = 0; j < cmd.params.length; j++) {
@@ -196,11 +214,82 @@ export class CommandHandler extends BuiltInModule {
         argList.push(await converter.execute(module, i))
       }
 
-      try {
-        await cmd.execute(module, argList)
-      } catch (e: any) {
-        return error(e)
+      await cmd.execute(module, argList)
+    } catch (e) {
+      return error(e)
+    }
+  }
+  // endregion
+
+  private async messageComponent(i: MessageComponentInteraction) {
+    const error = (e: any) => this.client.client.emit('messageComponentError', e)
+
+    try {
+      const handlers: MessageComponentHandler[] = []
+
+      for (const handler of this.registry.messageComponentHandlers) {
+        if (handler.componentId === handler.componentId && handler.componentType === i.componentType) {
+          handlers.push(handler)
+        }
+      }
+
+      for (const handler of handlers) {
+        const module = this.registry.modules.find((x) => x.messageComponentHandlers.includes(handler))
+        if (!module) continue
+        await handler.run(module, i)
+      }
+    } catch (e) {
+      error(e)
+    }
+  }
+
+  private async userContextMenu(i: UserContextMenuInteraction) {
+    const error = (error: Error) => this.client.client.emit('applicationCommandError', error, i)
+    try {
+      const cmd = this.registry.applicationCommands.find((x) => x.command.type === 'USER' && x.command.name === i.commandName)
+
+      if (!cmd) return
+
+      const module = this.registry.modules.find((x) => x.applicationCommands.includes(cmd))
+
+      if (!module) return
+
+      i.data = {
+        cts: this.client,
+        command: cmd,
+      }
+
+      for (const check of cmd.checks) {
+        if (!(await check(i))) return error(new ApplicationCommandCheckFailed(i, cmd))
+      }
+
+      await cmd.execute(module, [i])
+    } catch (e) {
+      return error(e)
+    }
+  }
+
+  private async messageContextMenu(i: MessageContextMenuInteraction) {
+    const error = (error: Error) => this.client.client.emit('applicationCommandError', error, i)
+    try {
+      const cmd = this.registry.applicationCommands.find((x) => x.command.type === 'MESSAGE' && x.command.name === i.commandName)
+
+      if (!cmd) return
+
+      const module = this.registry.modules.find((x) => x.applicationCommands.includes(cmd))
+
+      if (!module) return
+
+      i.data = {
+        cts: this.client,
+        command: cmd,
+      }
+
+      for (const check of cmd.checks) {
+        if (!(await check(i))) return error(new ApplicationCommandCheckFailed(i, cmd))
       }
+
+      await cmd.execute(module, [i])
     } catch (e) {
       return error(e)
     }
@@ -208,8 +297,28 @@ export class CommandHandler extends BuiltInModule {
 
   @listener('interactionCreate')
   async interaction(i: Interaction) {
-    if (i.isCommand()) {
-      await this.command(i)
+    const error = (e: any) => this.client.client.emit('interactionError', e, i)
+
+    try {
+      await this.client.options.applicationCommands.beforeRunCheck(i)
+      if (i.isCommand()) {
+        await this.command(i)
+        return
+      }
+      if (i.isMessageComponent()) {
+        await this.messageComponent(i)
+        return
+      }
+      if (i.isMessageContextMenu()) {
+        await this.messageContextMenu(i)
+        return
+      }
+      if (i.isUserContextMenu()) {
+        await this.userContextMenu(i)
+        return
+      }
+    } catch (e) {
+      return error(e)
     }
   }
 }

package/src/command/Command.ts

@@ -1,5 +1,5 @@
 import { Module } from '../structures'
-import { CommandInteraction, Message } from 'discord.js'
+import { CommandInteraction, ContextMenuInteraction, Message, MessageComponentInteraction } from 'discord.js'
 import { KCommandChecks } from '../constants'
 
 export type Argument = {
@@ -9,7 +9,7 @@ export type Argument = {
 }
 
 export type CheckFunction = (msg: Message) => boolean | Promise<boolean>
-export type SlashCheckFunction = (i: CommandInteraction) => boolean | Promise<boolean>
+export type ApplicationCommandCheckFunction = (i: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction) => boolean | Promise<boolean>
 
 export class Command {
   execute(module: Module, args: any[]) {

package/src/command/decorator.ts

@@ -10,6 +10,7 @@ import { ClientPermissionRequired, DMOnlyCommandError, GuildOnlyCommandError, Ow
 type CommandOptions = {
   name: string
   aliases: string[] | ((msg: Message) => string[])
+  optionTypes?: any[]
 }
 
 export const command = (options: Partial<CommandOptions> = {}) => {
@@ -22,7 +23,7 @@ export const command = (options: Partial<CommandOptions> = {}) => {
 
     let properties: Command[] = Reflect.getMetadata(KCommands, target)
 
-    const params: any[] = Reflect.getMetadata('design:paramtypes', target, propertyKey)
+    const params: any[] = options.optionTypes ?? Reflect.getMetadata('design:paramtypes', target, propertyKey)
 
     const optionals: number = Reflect.getMetadata(KOptionals, target, propertyKey) || -1
 

package/src/command/utils.ts

@@ -1,10 +1,10 @@
-import { CommandInteraction, Message } from 'discord.js'
-import type { CheckFunction, SlashCheckFunction } from './Command'
-import { KCommandChecks, KSlashCommandChecks } from '../constants'
+import { CommandInteraction, ContextMenuInteraction, Message, MessageComponentInteraction } from 'discord.js'
+import type { CheckFunction, ApplicationCommandCheckFunction } from './Command'
+import { KCommandChecks, KApplicationCommandChecks } from '../constants'
 
 export const createCheckDecorator = (
   execute: ((msg: Message) => boolean | Promise<boolean>) | null,
-  slashExecute?: (i: CommandInteraction) => boolean | Promise<boolean>,
+  executeApplicationCommand?: (i: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction) => boolean | Promise<boolean>,
 ): MethodDecorator => {
   return (target, propertyKey) => {
     if (execute) {
@@ -16,13 +16,13 @@ export const createCheckDecorator = (
         Reflect.defineMetadata(KCommandChecks, properties, target, propertyKey)
       }
     }
-    if (slashExecute) {
-      let properties: SlashCheckFunction[] = Reflect.getMetadata(KSlashCommandChecks, target, propertyKey)
+    if (executeApplicationCommand) {
+      let properties: ApplicationCommandCheckFunction[] = Reflect.getMetadata(KApplicationCommandChecks, target, propertyKey)
       if (properties) {
-        properties.push(slashExecute)
+        properties.push(executeApplicationCommand)
       } else {
-        properties = [slashExecute]
-        Reflect.defineMetadata(KSlashCommandChecks, properties, target, propertyKey)
+        properties = [executeApplicationCommand]
+        Reflect.defineMetadata(KApplicationCommandChecks, properties, target, propertyKey)
       }
     }
   }

package/src/constants.ts

@@ -1,6 +1,6 @@
 export const KCommands = Symbol('Command.TS Commands')
 
-export const KSlashCommands = Symbol('Command.TS Slash Commands')
+export const KApplicationCommands = Symbol('Command.TS Slash Commands')
 
 export const KSlashCommandOptions = Symbol('Command.TS Slash Command Options')
 
@@ -22,4 +22,6 @@ export const KSlashArgumentConverters = Symbol('Command.TS Slash Argument Conver
 
 export const KCommandChecks = Symbol('Command.TS Command Checks')
 
-export const KSlashCommandChecks = Symbol('Command.TS Slash Command Checks')
+export const KApplicationCommandChecks = Symbol('Command.TS Slash Command Checks')
+
+export const KMessageComponentHandlers = Symbol('Command.TS Message Component Handlers')

package/src/error/ArgumentConverterNotFound.ts

@@ -1,6 +1,6 @@
 import { CommandInteraction, Message } from 'discord.js'
 import type { Argument } from '../command'
-import type { SlashArgument } from '../slashCommand'
+import type { SlashArgument } from '../applicationCommand'
 
 export class ArgumentConverterNotFound extends Error {
   constructor(public type: Argument, public msg: Message) {

package/src/error/CommandCheckFailed.ts

@@ -1,6 +1,6 @@
-import { CommandInteraction, Message } from 'discord.js'
+import { CommandInteraction, ContextMenuInteraction, Message, MessageComponentInteraction } from 'discord.js'
 import { Command } from '../command'
-import { SlashCommand } from '../slashCommand'
+import { AppCommand } from '../applicationCommand'
 
 export class CommandCheckFailed extends Error {
   constructor(public msg: Message, public command: Command) {
@@ -8,8 +8,8 @@ export class CommandCheckFailed extends Error {
   }
 }
 
-export class SlashCommandCheckFailed extends Error {
-  constructor(public interaction: CommandInteraction, public command: SlashCommand) {
+export class ApplicationCommandCheckFailed extends Error {
+  constructor(public interaction: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction, public command: AppCommand) {
     super()
   }
 }

package/src/error/checks/SlashCommandGlobalCheckError.ts

@@ -0,0 +1,7 @@
+import { CommandInteraction } from 'discord.js'
+
+export class SlashCommandGlobalCheckError extends Error {
+  constructor(public i: CommandInteraction) {
+    super('Slash command before-run check failed.')
+  }
+}

package/src/index.ts

@@ -7,4 +7,5 @@ export * from './error'
 export * from './command'
 export * from './listener'
 export * from './builtinModules/BuiltInModule'
-export * from './slashCommand'
+export * from './applicationCommand'
+export * from './messageComponents'

package/src/messageComponents/base.ts

@@ -0,0 +1,12 @@
+import { MessageComponentInteraction, MessageComponentType } from 'discord.js'
+import { Module } from '../structures'
+
+export type MessageComponentExecutor = (i: MessageComponentInteraction) => void | Promise<void>
+
+export class MessageComponentHandler {
+  constructor(public componentId: string, public componentType: Exclude<MessageComponentType, 'ACTION_ROW'>, public execute: MessageComponentExecutor) {}
+
+  run(module: Module, i: MessageComponentInteraction) {
+    return this.execute.apply(module, [i])
+  }
+}

package/src/messageComponents/button.ts

@@ -0,0 +1,26 @@
+import { MessageComponentExecutor, MessageComponentHandler } from './base'
+import { checkTarget } from '../utils'
+import { KMessageComponentHandlers } from '../constants'
+
+export class ButtonInteractionHandler extends MessageComponentHandler {
+  constructor(id: string, execute: MessageComponentExecutor) {
+    super(id, 'BUTTON', execute)
+  }
+}
+
+export const messageButton = (id: string): MethodDecorator => {
+  return (target, propertyKey) => {
+    checkTarget(target)
+
+    const handler = new ButtonInteractionHandler(id, Reflect.get(target, propertyKey))
+
+    let properties: MessageComponentHandler[] = Reflect.getMetadata(KMessageComponentHandlers, target)
+
+    if (properties) {
+      properties.push(handler)
+    } else {
+      properties = [handler]
+      Reflect.defineMetadata(KMessageComponentHandlers, properties, target)
+    }
+  }
+}

package/src/messageComponents/index.ts

@@ -0,0 +1,2 @@
+export * from './button'
+export * from './selectMenu'

package/src/messageComponents/selectMenu.ts

@@ -0,0 +1,26 @@
+import { MessageComponentExecutor, MessageComponentHandler } from './base'
+import { checkTarget } from '../utils'
+import { KMessageComponentHandlers } from '../constants'
+
+export class SelectMenuInteractionHandler extends MessageComponentHandler {
+  constructor(id: string, execute: MessageComponentExecutor) {
+    super(id, 'SELECT_MENU', execute)
+  }
+}
+
+export const messageSelectMenu = (id: string): MethodDecorator => {
+  return (target, propertyKey) => {
+    checkTarget(target)
+
+    const handler = new SelectMenuInteractionHandler(id, Reflect.get(target, propertyKey))
+
+    let properties: MessageComponentHandler[] = Reflect.getMetadata(KMessageComponentHandlers, target)
+
+    if (properties) {
+      properties.push(handler)
+    } else {
+      properties = [handler]
+      Reflect.defineMetadata(KMessageComponentHandlers, properties, target)
+    }
+  }
+}

package/src/structures/CommandClient.ts

@@ -1,31 +1,38 @@
 import _ from 'lodash'
 import { Registry } from './Registry'
-import { Client, Message, Snowflake, User } from 'discord.js'
+import { Client, CommandInteraction, Interaction, Message, Snowflake, User } from 'discord.js'
 import { BuiltinCommandConverters, BuiltinSlashCommandConverters, CommandHandler } from '../builtinModules'
 import { CoolDownAdapter, DefaultCoolDownAdapter } from '../command'
-import { REST } from '@discordjs/rest'
 import { Logger } from 'tslog'
 
 export interface CommandOptions {
   prefix: string | ((msg: any) => string | Promise<string | string[]> | string[]) | string[]
   check: (msg: Message) => boolean | Promise<boolean>
+  globalAliases: (cmd: string, msg: Message) => string[] | Promise<string[]>
 }
 
 export interface SlashCommandOptions {
+  check: (i: CommandInteraction) => boolean | Promise<boolean>
+}
+
+export interface ApplicationCommandOptions {
   guild?: Snowflake | Snowflake[]
   autoSync: boolean
+  beforeRunCheck: (i: Interaction) => void | Promise<void>
 }
 
 export interface CommandClientOptions {
   command: CommandOptions
   owners: 'auto' | Snowflake[]
   slashCommands: SlashCommandOptions
+  applicationCommands: ApplicationCommandOptions
 }
 
 export interface CommandClientOptionsParam {
   command: Partial<CommandOptions>
   owners: 'auto' | string[]
   slashCommands: Partial<SlashCommandOptions>
+  applicationCommands: Partial<ApplicationCommandOptions>
 }
 
 export class CommandClient {
@@ -34,9 +41,6 @@ export class CommandClient {
   registry = new Registry(this)
   client: Client
   coolDownAdapter: CoolDownAdapter
-  rest = new REST({
-    version: '9',
-  })
   logger: Logger
 
   private _isReady = false
@@ -51,13 +55,12 @@ export class CommandClient {
 
   async ready() {
     if (this._isReady) return
-    this.rest.setToken(this.client.token!)
     this._isReady = true
     if (this.options.owners === 'auto') {
       const owners = await this.fetchOwners()
       this.owners.push(...owners)
     }
-    if (this.options.slashCommands.autoSync) {
+    if (this.options.applicationCommands.autoSync) {
       await this.registry.syncCommands()
     }
   }
@@ -70,10 +73,15 @@ export class CommandClient {
         command: {
           prefix: '!',
           check: () => true,
+          globalAliases: () => [],
         },
         owners: 'auto',
         slashCommands: {
-          autoSync: true,
+          check: () => true,
+        },
+        applicationCommands: {
+          autoSync: false,
+          beforeRunCheck: () => {},
         },
       },
       options,

package/src/structures/Module.ts

@@ -1,9 +1,10 @@
-import { KArgumentConverters, KCommands, KListeners, KModulePath, KSlashArgumentConverters, KSlashCommands } from '../constants'
+import { KArgumentConverters, KCommands, KListeners, KMessageComponentHandlers, KModulePath, KSlashArgumentConverters, KApplicationCommands } from '../constants'
 import type { Command } from '../command'
 import { Listener } from '../listener'
 import { ArgumentConverter, SlashArgumentConverter } from '../command'
-import { SlashCommand } from '../slashCommand'
+import { AppCommand } from '../applicationCommand'
 import { CommandClient } from './CommandClient'
+import { MessageComponentHandler } from '../messageComponents/base'
 
 export abstract class Module {
   commandClient!: CommandClient
@@ -30,8 +31,12 @@ export abstract class Module {
     return Reflect.getMetadata(KSlashArgumentConverters, this) || []
   }
 
-  get slashCommands(): SlashCommand[] {
-    return Reflect.getMetadata(KSlashCommands, this) || []
+  get applicationCommands(): AppCommand[] {
+    return Reflect.getMetadata(KApplicationCommands, this) || []
+  }
+
+  get messageComponentHandlers(): MessageComponentHandler[] {
+    return Reflect.getMetadata(KMessageComponentHandlers, this) || []
   }
 
   get path(): string | undefined {

package/src/structures/Registry.ts

@@ -7,9 +7,9 @@ import { InvalidModuleError, InvalidTargetError, ModuleLoadError } from '../erro
 import { Collection, Guild } from 'discord.js'
 import walkSync from 'walk-sync'
 import { ArgumentConverter } from '../command'
-import { SlashCommand } from '../slashCommand'
-import { Routes } from 'discord-api-types/v9'
+import { AppCommand } from '../applicationCommand'
 import * as fs from 'fs'
+import { MessageComponentHandler } from '../messageComponents/base'
 
 type ListenerExecutor = {
   event: string
@@ -57,11 +57,21 @@ export class Registry {
     return result
   }
 
-  get slashCommands(): SlashCommand[] {
-    const result: SlashCommand[] = []
+  get applicationCommands(): AppCommand[] {
+    const result: AppCommand[] = []
 
     for (const [, module] of this.modules) {
-      result.push(...module.slashCommands)
+      result.push(...module.applicationCommands)
+    }
+
+    return result
+  }
+
+  get messageComponentHandlers(): MessageComponentHandler[] {
+    const result: MessageComponentHandler[] = []
+
+    for (const [, module] of this.modules) {
+      result.push(...module.messageComponentHandlers)
     }
 
     return result
@@ -128,19 +138,17 @@ export class Registry {
 
   async syncCommands() {
     this.logger.debug(`Syncing commands...`)
-    const commands = this.slashCommands.filter((x) => !x.guild)
-    const guild = this.client.options.slashCommands.guild
+    const commands = this.applicationCommands.filter((x) => !x.guild)
+    const guild = this.client.options.applicationCommands.guild
     if (guild) {
       const syncForGuild = async (g: Guild) => {
         this.logger.debug(`Syncing for guild ${g.name}(${g.id})`)
         const commandsToRegister = [
-          ...commands.map((x) => x.commandBuilder),
-          ...this.slashCommands.filter((y) => y.guild === g.id || y.guild?.includes(g.id) || false).map((x) => x.commandBuilder),
+          ...commands.map((x) => x.command),
+          ...this.applicationCommands.filter((y) => y.guild === g.id || y.guild?.includes(g.id) || false).map((x) => x.command),
         ]
         this.logger.debug(`Command List: ${commandsToRegister.map((x) => x.name).join(', ')}`)
-        await this.client.rest.put(Routes.applicationGuildCommands(this.client.client.application!.id, g.id) as any, {
-          body: commandsToRegister.map((x) => x.toJSON()),
-        })
+        await g.commands.set(commandsToRegister)
       }
 
       if (typeof guild === 'string') {
@@ -152,9 +160,7 @@ export class Registry {
       }
     } else {
       this.logger.debug('Syncing global...')
-      await this.client.rest.put(Routes.applicationCommands(this.client.client.application!.id) as any, {
-        body: commands.map((x) => x.commandBuilder.toJSON()),
-      })
+      await this.client.client.application?.commands.set(commands.map((x) => x.command))
     }
     this.logger.debug('Syncing ended.')
   }

package/src/typings.ts

@@ -1,18 +1,30 @@
 import type { Command } from './command'
 import { CommandClient } from './structures'
-import { SlashCommand } from './slashCommand'
+import { AppCommand } from './applicationCommand'
 
 declare module 'discord.js' {
   interface Message {
     data: {
-      command: Command
+      command: Command | null
       prefix: string
       cts: CommandClient
     }
   }
   interface CommandInteraction {
     data: {
-      command: SlashCommand
+      command: AppCommand
+      cts: CommandClient
+    }
+  }
+  interface MessageComponentInteraction {
+    data: {
+      command: AppCommand
+      cts: CommandClient
+    }
+  }
+  interface ContextMenuInteraction {
+    data: {
+      command: AppCommand
       cts: CommandClient
     }
   }

package/test/index.ts

@@ -8,12 +8,12 @@ const client = new Client({
 })
 
 const cts = new CommandClient({
-  owners: [],
+  owners: 'auto',
   client,
   command: {
     prefix: '!',
   },
-  slashCommands: {
+  applicationCommands: {
     autoSync: true,
     guild: '832938554438844438',
   },