@pikokr/command.ts 3.0.0-dev.a94f324 → 3.0.0-dev.ca01eb5

package/src/structures/Registry.ts

@@ -1,20 +1,14 @@
 import { CommandClient } from './CommandClient'
 import { Module } from './Module'
-import { Command } from '../command'
-import {
-  KBuiltInModule,
-  KListenerExecuteCache,
-  KModulePath,
-} from '../constants'
+import { Command, SlashArgumentConverter } from '../command'
+import { KBuiltInModule, KListenerExecuteCache, KModulePath } from '../constants'
 import path from 'path'
-import {
-  InvalidModuleError,
-  InvalidTargetError,
-  ModuleLoadError,
-} from '../error'
-import { Collection } from 'discord.js'
+import { InvalidModuleError, InvalidTargetError, ModuleLoadError } from '../error'
+import { Collection, Guild } from 'discord.js'
 import walkSync from 'walk-sync'
-import { ArgumentConverter } from '../command/ArgumentConverter'
+import { ArgumentConverter } from '../command'
+import { SlashCommand } from '../slashCommand'
+import { Routes } from 'discord-api-types/v9'
 
 type ListenerExecutor = {
   event: string
@@ -46,6 +40,26 @@ export class Registry {
     return result
   }
 
+  get slashArgumentConverters(): SlashArgumentConverter[] {
+    const result: SlashArgumentConverter[] = []
+
+    for (const [, module] of this.modules) {
+      result.push(...module.slashArgumentConverters)
+    }
+
+    return result
+  }
+
+  get slashCommands(): SlashCommand[] {
+    const result: SlashCommand[] = []
+
+    for (const [, module] of this.modules) {
+      result.push(...module.slashCommands)
+    }
+
+    return result
+  }
+
   registerModule(module: Module) {
     this.modules.set(Symbol(module.constructor.name), module)
 
@@ -62,15 +76,15 @@ export class Registry {
     return module
   }
 
-  loadModulesIn(dir: string, absolute = false) {
+  async loadModulesIn(dir: string, absolute = false) {
     let p = absolute ? dir : path.join(require.main!.path, dir)
 
     for (const i of walkSync(p)) {
-      this.loadModule(path.join(p, i), true)
+      await this.loadModule(path.join(p, i), true)
     }
   }
 
-  loadModule(file: string, absolute: boolean = false) {
+  async loadModule(file: string, absolute: boolean = false) {
     let p = absolute ? file : path.join(require.main!.path, file)
 
     let m
@@ -93,23 +107,43 @@ export class Registry {
 
     this.registerModule(mod)
 
-    mod.load()
+    await mod.load()
 
     m.loaded = true
 
     return mod
   }
 
-  unregisterModule(module: Module) {
-    if (Reflect.getMetadata(KBuiltInModule, module))
-      throw new Error('Built-in modules cannot be unloaded')
+  async syncCommands() {
+    const commands = this.slashCommands.filter((x) => !x.guild)
+    const guild = this.client.options.slashCommands.guild
+    if (guild) {
+      const syncForGuild = async (g: Guild) => {
+        await this.client.rest.put(Routes.applicationGuildCommands(this.client.client.application!.id, g.id) as any, {
+          body: commands.map((x) => x.commandBuilder.toJSON()),
+        })
+      }
+
+      if (typeof guild === 'string') {
+        await syncForGuild(await this.client.client.guilds.fetch(guild))
+      } else {
+        for (const g of guild) {
+          await syncForGuild(await this.client.client.guilds.fetch(g))
+        }
+      }
+    } else {
+      await this.client.rest.put(Routes.applicationCommands(this.client.client.application!.id) as any, {
+        body: commands.map((x) => x.commandBuilder.toJSON()),
+      })
+    }
+  }
+
+  async unregisterModule(module: Module) {
+    if (Reflect.getMetadata(KBuiltInModule, module)) throw new Error('Built-in modules cannot be unloaded')
     const symbol = this.modules.findKey((x) => x === module)
     if (!symbol) return module
-    module.unload()
-    const list: ListenerExecutor[] = Reflect.getMetadata(
-      KListenerExecuteCache,
-      module,
-    )
+    await module.unload()
+    const list: ListenerExecutor[] = Reflect.getMetadata(KListenerExecuteCache, module)
     for (const listener of list) {
       this.client.client.removeListener(listener.event, listener.execute)
     }
@@ -117,13 +151,46 @@ export class Registry {
     return module
   }
 
-  unloadModule(module: Module) {
+  async unloadModule(module: Module) {
     const p = Reflect.getMetadata(KModulePath, module)
 
-    if (!p)
-      throw new InvalidModuleError('This module is not loaded by loadModule.')
+    if (!p) throw new InvalidModuleError('This module is not loaded by loadModule.')
 
-    this.unregisterModule(module)
+    await this.unregisterModule(module)
     delete require.cache[p]
   }
+
+  async reloadModule(module: Module) {
+    await module.beforeReload()
+    const p = Reflect.getMetadata(KModulePath, module)
+    await this.unloadModule(module)
+    const mod = await this.loadModule(p, true)
+    await mod.afterReload()
+    return true
+  }
+
+  async reloadAll() {
+    const results: {
+      path: string
+      success: boolean
+      error?: Error
+    }[] = []
+
+    for (const [, module] of this.modules.filter((x) => !!x.path)) {
+      try {
+        await this.reloadModule(module)
+        results.push({
+          path: module.path!,
+          success: false,
+        })
+      } catch (e: any) {
+        results.push({
+          error: e,
+          path: module.path!,
+          success: false,
+        })
+      }
+    }
+    return results
+  }
 }

package/src/typings.ts

@@ -0,0 +1,19 @@
+import type { Command } from './command'
+import { CommandClient } from './structures'
+import { SlashCommand } from './slashCommand'
+
+declare module 'discord.js' {
+  interface Message {
+    data: {
+      command: Command
+      prefix: string
+      cts: CommandClient
+    }
+  }
+  interface CommandInteraction {
+    data: {
+      command: SlashCommand
+      cts: CommandClient
+    }
+  }
+}

package/test/index.ts

@@ -13,6 +13,10 @@ const cts = new CommandClient({
   command: {
     prefix: '!',
   },
+  slashCommands: {
+    autoSync: true,
+    guild: '832938554438844438',
+  },
 })
 
 require('./modules/test')

package/test/modules/test.ts

@@ -1,5 +1,6 @@
-import { command, CommandClient, Module, listener, optional } from '../../src'
-import { Message } from 'discord.js'
+import { command, CommandClient, coolDown, CoolDownError, CoolDownType, listener, Module, option, rest, slashCommand } from '../../src'
+import { CommandInteraction, Message } from 'discord.js'
+import { SlashCommandBuilder } from '@discordjs/builders'
 
 class Test extends Module {
   constructor(private client: CommandClient) {
@@ -28,15 +29,41 @@ class Test extends Module {
   }
 
   @listener('commandError')
-  error(err: Error) {
+  error(err: Error, msg: Message) {
+    if (err instanceof CoolDownError) {
+      return msg.reply(`쿨다운: <t:${(err.endsAt.getTime() / 1000).toFixed(0)}:R>`)
+    }
+    console.error(err)
+  }
+  @listener('slashCommandError')
+  slashCommandError(err: Error, msg: CommandInteraction) {
+    if (err instanceof CoolDownError) {
+      return msg.reply({
+        content: `쿨다운: <t:${(err.endsAt.getTime() / 1000).toFixed(0)}:R>`,
+        ephemeral: true,
+      })
+    }
     console.error(err)
   }
 
   @command()
-  test(msg: Message, @optional asdf: string = 'wa sans') {
-    console.log(asdf)
+  @coolDown(CoolDownType.USER, 10)
+  test(msg: Message, @rest asdf: string = 'wa sans') {
     msg.reply(asdf)
   }
+
+  @slashCommand({
+    command: new SlashCommandBuilder()
+      .setName('test')
+      .setDescription('test command')
+      .addStringOption((builder) => builder.setName('test').setDescription('test option').setRequired(false)),
+  })
+  @coolDown(CoolDownType.USER, 10)
+  async testSlash(i: CommandInteraction, @option('test') test: string = 'wa sans') {
+    return i.reply({
+      content: test,
+    })
+  }
 }
 
 export function install(client: CommandClient) {

package/pagesconfig.json

@@ -1,13 +0,0 @@
-{
-  "groups": [
-    {
-      "title": "DOCS",
-      "pages": [
-        {
-          "title": "Intro",
-          "source": "./docs/README.md"
-        }
-      ]
-    }
-  ]
-}