@pikokr/command.ts 3.2.4-dev.434c22e → 4.0.0

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,9 +1,8 @@
 import _ from 'lodash'
 import { Registry } from './Registry'
-import { Client, Message, Snowflake, User } from 'discord.js'
-import { BuiltinCommandConverters, BuiltinSlashCommandConverters, CommandHandler } from '../builtinModules'
+import { Client, CommandInteraction, Interaction, Message, Snowflake, User } from 'discord.js'
+import { BuiltinCommandConverters, BuiltinApplicationCommandConverters, CommandHandler } from '../builtinModules'
 import { CoolDownAdapter, DefaultCoolDownAdapter } from '../command'
-import { REST } from '@discordjs/rest'
 import { Logger } from 'tslog'
 
 export interface CommandOptions {
@@ -13,20 +12,27 @@ export interface CommandOptions {
 }
 
 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 {
@@ -35,9 +41,6 @@ export class CommandClient {
   registry = new Registry(this)
   client: Client
   coolDownAdapter: CoolDownAdapter
-  rest = new REST({
-    version: '9',
-  })
   logger: Logger
 
   private _isReady = false
@@ -52,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()
     }
   }
@@ -75,7 +77,11 @@ export class CommandClient {
         },
         owners: 'auto',
         slashCommands: {
-          autoSync: true,
+          check: () => true,
+        },
+        applicationCommands: {
+          autoSync: false,
+          beforeRunCheck: () => {},
         },
       },
       options,
@@ -90,6 +96,6 @@ export class CommandClient {
     this.client.once('ready', () => this.ready())
     this.registry.registerModule(new CommandHandler(this.registry))
     this.registry.registerModule(new BuiltinCommandConverters(this))
-    this.registry.registerModule(new BuiltinSlashCommandConverters(this))
+    this.registry.registerModule(new BuiltinApplicationCommandConverters(this))
   }
 }

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 { ArgumentConverter, ApplicationCommandArgumentConverter } from '../command'
+import { AppCommand } from '../applicationCommand'
 import { CommandClient } from './CommandClient'
+import { MessageComponentHandler } from '../messageComponents/base'
 
 export abstract class Module {
   commandClient!: CommandClient
@@ -26,12 +27,16 @@ export abstract class Module {
     return Reflect.getMetadata(KArgumentConverters, this) || []
   }
 
-  get slashArgumentConverters(): SlashArgumentConverter[] {
+  get applicationCommandArgumentConverters(): ApplicationCommandArgumentConverter[] {
     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

@@ -1,15 +1,15 @@
 import { CommandClient } from './CommandClient'
 import { Module } from './Module'
-import { Command, SlashArgumentConverter } from '../command'
+import { Command, ApplicationCommandArgumentConverter } from '../command'
 import { KBuiltInModule, KListenerExecuteCache, KModulePath } from '../constants'
 import path from 'path'
 import { InvalidModuleError, InvalidTargetError, ModuleLoadError } from '../error'
 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
@@ -47,21 +47,31 @@ export class Registry {
     return result
   }
 
-  get slashArgumentConverters(): SlashArgumentConverter[] {
-    const result: SlashArgumentConverter[] = []
+  get applicationCommandArgumentConverters(): ApplicationCommandArgumentConverter[] {
+    const result: ApplicationCommandArgumentConverter[] = []
 
     for (const [, module] of this.modules) {
-      result.push(...module.slashArgumentConverters)
+      result.push(...module.applicationCommandArgumentConverters)
     }
 
     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,6 +1,6 @@
 import type { Command } from './command'
 import { CommandClient } from './structures'
-import { SlashCommand } from './slashCommand'
+import { AppCommand } from './applicationCommand'
 
 declare module 'discord.js' {
   interface Message {
@@ -12,7 +12,19 @@ declare module 'discord.js' {
   }
   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',
   },

package/test/modules/dev.ts

@@ -1,6 +1,5 @@
-import { BuiltInModule, CommandClient, ownerOnly, slashCommand, listener, SlashCommandCheckFailed } from '../../src'
+import { BuiltInModule, CommandClient, ownerOnly, applicationCommand, listener, ApplicationCommandCheckFailed } from '../../src'
 import { CommandInteraction } from 'discord.js'
-import { SlashCommandBuilder } from '@discordjs/builders'
 
 export class Dev extends BuiltInModule {
   constructor(private cts: CommandClient) {
@@ -9,7 +8,7 @@ export class Dev extends BuiltInModule {
 
   @listener('slashCommandError')
   slashError(e: Error, i: CommandInteraction) {
-    if (e instanceof SlashCommandCheckFailed) {
+    if (e instanceof ApplicationCommandCheckFailed) {
       return i.reply({
         content: 'Command before-run check failed',
         ephemeral: true,
@@ -18,8 +17,13 @@ export class Dev extends BuiltInModule {
     console.error(e.message)
   }
 
-  @slashCommand({
-    command: new SlashCommandBuilder().setName('reload').setDescription('리로드 커맨드'),
+  // new SlashCommandBuilder().setName('reload').setDescription('리로드 커맨드')
+  @applicationCommand({
+    command: {
+      name: 'reload',
+      type: 'CHAT_INPUT',
+      description: '리로드 커맨드',
+    },
   })
   @ownerOnly
   async reload(i: CommandInteraction) {

package/test/modules/test.ts

@@ -1,12 +1,23 @@
-import { command, CommandClient, coolDown, CoolDownError, CoolDownType, listener, Module, option, rest, slashCommand } from '../../src'
-import { CommandInteraction, Message } from 'discord.js'
-import { SlashCommandBuilder } from '@discordjs/builders'
+import { command, CommandClient, coolDown, CoolDownError, CoolDownType, listener, messageButton, messageSelectMenu, Module, option, rest, applicationCommand } from '../../src'
+import {
+  ButtonInteraction,
+  CommandInteraction,
+  ContextMenuInteraction,
+  Message,
+  MessageActionRow,
+  MessageButton,
+  MessageContextMenuInteraction,
+  MessageSelectMenu,
+  SelectMenuInteraction,
+  UserContextMenuInteraction,
+} from 'discord.js'
 
 class Test extends Module {
   constructor(private client: CommandClient) {
     super()
   }
 
+  // region lifetime method
   load() {
     console.log('load')
   }
@@ -22,6 +33,7 @@ class Test extends Module {
   afterReload() {
     console.log('after reload')
   }
+  // endregion
 
   @listener('ready')
   ready() {
@@ -35,8 +47,8 @@ class Test extends Module {
     }
     console.error(err)
   }
-  @listener('slashCommandError')
-  slashCommandError(err: Error, msg: CommandInteraction) {
+  @listener('applicationCommandError')
+  slashCommandError(err: Error, msg: CommandInteraction | ContextMenuInteraction) {
     if (err instanceof CoolDownError) {
       return msg.reply({
         content: `쿨다운: <t:${(err.endsAt.getTime() / 1000).toFixed(0)}:R>`,
@@ -46,22 +58,83 @@ class Test extends Module {
     console.error(err)
   }
 
-  @command()
+  @applicationCommand({
+    command: {
+      type: 'CHAT_INPUT',
+      name: 'test',
+      description: 'test',
+      options: [
+        {
+          type: 'STRING',
+          name: 'asdf',
+          description: 'test',
+        },
+      ],
+    },
+  })
   @coolDown(CoolDownType.USER, 10)
-  test(msg: Message, @rest asdf: string = 'wa sans') {
-    msg.reply(asdf)
+  coolDownSlash(i: CommandInteraction, @option('asdf') asdf: string = 'wa sans') {
+    i.reply({
+      content: asdf,
+      components: [
+        new MessageActionRow().addComponents(new MessageButton().setLabel('test').setCustomId('testButton').setStyle('PRIMARY')),
+        new MessageActionRow().addComponents(
+          new MessageSelectMenu()
+            .setCustomId('testSelectMenu')
+            .setPlaceholder('test')
+            .setMinValues(1)
+            .setOptions(
+              new Array(10).fill(1).map((_, i) => ({
+                label: `${i}`,
+                value: `${i}`,
+              })),
+            ),
+        ),
+      ],
+    })
+  }
+
+  @applicationCommand({
+    command: {
+      type: 'MESSAGE',
+      name: 'contextMenuTest',
+      defaultPermission: true,
+    },
+  })
+  @coolDown(CoolDownType.USER, 10)
+  async contextMenuMessage(i: MessageContextMenuInteraction) {
+    return i.reply({
+      content: `message id: ${i.targetMessage.id}`,
+    })
   }
 
-  @slashCommand({
-    command: new SlashCommandBuilder()
-      .setName('test')
-      .setDescription('test command')
-      .addStringOption((builder) => builder.setName('test').setDescription('test option').setRequired(false)),
+  @applicationCommand({
+    command: {
+      type: 'USER',
+      name: 'contextMenuTest',
+      defaultPermission: true,
+    },
   })
   @coolDown(CoolDownType.USER, 10)
-  async testSlash(i: CommandInteraction, @option('test') test: string = 'wa sans') {
+  async contextMenuUser(i: UserContextMenuInteraction) {
     return i.reply({
-      content: test,
+      content: `user id: ${i.targetUser.id}`,
+    })
+  }
+
+  @messageButton('testButton')
+  async testButton(i: ButtonInteraction) {
+    await i.update({
+      content: 'test',
+      components: [],
+    })
+  }
+
+  @messageSelectMenu('testSelectMenu')
+  async testSelectMenu(i: SelectMenuInteraction) {
+    await i.update({
+      content: i.values.join(', '),
+      components: [],
     })
   }
 }

package/src/builtinModules/BuiltinSlashCommandConverters.ts

@@ -1,23 +0,0 @@
-import { BuiltInModule } from './BuiltInModule'
-import { slashArgumentConverter } from '../command'
-import { Client, CommandInteraction, CommandInteractionOptionResolver } from 'discord.js'
-import { CommandClient } from '../structures'
-
-export class BuiltinSlashCommandConverters extends BuiltInModule {
-  client: Client
-
-  constructor(private cts: CommandClient) {
-    super()
-    this.client = cts.client
-  }
-
-  @slashArgumentConverter(CommandInteraction)
-  message(interaction: CommandInteraction) {
-    return interaction
-  }
-
-  @slashArgumentConverter(CommandInteractionOptionResolver)
-  optionResolver(interaction: CommandInteraction): CommandInteractionOptionResolver {
-    return interaction.options as CommandInteractionOptionResolver
-  }
-}

package/src/slashCommand/SlashCommand.ts

@@ -1,29 +0,0 @@
-import { SlashCommandBuilder } from '@discordjs/builders'
-import { Module } from '../structures'
-import { Snowflake } from 'discord.js'
-import { KSlashCommandChecks } from '../constants'
-import { SlashCheckFunction } from '../command'
-
-export type SlashArgument = {
-  type: any
-  name?: string
-}
-
-export class SlashCommand {
-  get checks(): SlashCheckFunction[] {
-    return Reflect.getMetadata(KSlashCommandChecks, this.module, this.key) || []
-  }
-
-  execute(module: Module, args: any[]) {
-    return this.run.apply(module, args)
-  }
-
-  constructor(
-    public commandBuilder: SlashCommandBuilder | Omit<SlashCommandBuilder, 'addSubcommand' | 'addSubcommandGroup'>,
-    private run: Function,
-    public module: Module,
-    public params: SlashArgument[],
-    public guild: Snowflake | Snowflake[] | undefined,
-    private key: string | symbol,
-  ) {}
-}

package/src/slashCommand/index.ts

@@ -1,2 +0,0 @@
-export * from './decorator'
-export * from './SlashCommand'