@pikokr/command.ts 3.0.0-dev.7170769 → 3.0.0-dev.85a29c3

package/src/structures/Registry.ts

@@ -1,35 +1,68 @@
 import { CommandClient } from './CommandClient'
 import { Module } from './Module'
 import { Command } from '../command'
-import { KCommands, KModulePath } from '../constants'
+import { KBuiltInModule, KListenerExecuteCache, KModulePath } from '../constants'
 import path from 'path'
-import {
-  InvalidModuleError,
-  InvalidTargetError,
-  ModuleLoadError,
-} from '../error'
+import { InvalidModuleError, InvalidTargetError, ModuleLoadError } from '../error'
+import { Collection } from 'discord.js'
+import walkSync from 'walk-sync'
+import { ArgumentConverter } from '../command'
+
+type ListenerExecutor = {
+  event: string
+  execute: any
+}
 
 export class Registry {
-  constructor(private client: CommandClient) {}
+  constructor(public client: CommandClient) {}
 
-  modules: Module[] = []
+  modules: Collection<symbol, Module> = new Collection()
 
   get commands(): Command[] {
     const result: Command[] = []
 
-    for (const module of this.modules) {
-      const commands = Reflect.getMetadata(KCommands, module)
-      result.push(...commands)
+    for (const [, module] of this.modules) {
+      result.push(...module.commands)
+    }
+
+    return result
+  }
+
+  get argumentConverters(): ArgumentConverter[] {
+    const result: ArgumentConverter[] = []
+
+    for (const [, module] of this.modules) {
+      result.push(...module.argumentConverters)
     }
 
     return result
   }
 
   registerModule(module: Module) {
-    // TODO
+    this.modules.set(Symbol(module.constructor.name), module)
+
+    const list: ListenerExecutor[] = []
+
+    for (const listener of module.listeners) {
+      const bound = listener.execute.bind(module)
+      list.push({ event: listener.name, execute: bound })
+      this.client.client.on(listener.name, bound)
+    }
+
+    Reflect.defineMetadata(KListenerExecuteCache, list, module)
+
+    return module
+  }
+
+  async loadModulesIn(dir: string, absolute = false) {
+    let p = absolute ? dir : path.join(require.main!.path, dir)
+
+    for (const i of walkSync(p)) {
+      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
@@ -40,22 +73,78 @@ export class Registry {
       throw new ModuleLoadError(p)
     }
 
+    if (m.loaded) throw new Error('MODULE_ALREADY_LOADED')
+
     if (!m.install) throw new InvalidModuleError('Install function not found.')
 
-    const mod = m.install()
+    const mod = m.install(this.client)
 
     if (!(mod instanceof Module)) throw new InvalidTargetError()
 
     Reflect.defineMetadata(KModulePath, require.resolve(p), mod)
 
-    this.registerModule(m)
+    this.registerModule(mod)
+
+    await mod.load()
+
+    m.loaded = true
+
+    return mod
+  }
+
+  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
+    await module.unload()
+    const list: ListenerExecutor[] = Reflect.getMetadata(KListenerExecuteCache, module)
+    for (const listener of list) {
+      this.client.client.removeListener(listener.event, listener.execute)
+    }
+    this.modules.delete(symbol)
+    return module
   }
 
-  unregisterModule(module: Module) {
-    // TODO
+  async unloadModule(module: Module) {
+    const p = Reflect.getMetadata(KModulePath, module)
+
+    if (!p) throw new InvalidModuleError('This module is not loaded by loadModule.')
+
+    await this.unregisterModule(module)
+    delete require.cache[p]
   }
 
-  unloadModule(module: Module) {
-    // TODO
+  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/structures/index.ts

@@ -1,2 +1,3 @@
-export * from './CommandClient'
 export * from './Module'
+export * from './CommandClient'
+export * from './Registry'

package/src/typings.ts

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

package/src/utils.ts

@@ -0,0 +1,6 @@
+import { Module } from './structures'
+import { InvalidTargetError } from './error'
+
+export const checkTarget = (target: Object) => {
+  if (!(target instanceof Module)) throw new InvalidTargetError()
+}

package/test/index.ts

@@ -1,6 +1,5 @@
 import { Client, Intents, IntentsString } from 'discord.js'
 import { CommandClient } from '../src'
-import { DJSAdapter } from '../src/adapters/DJSAdapter'
 
 const config = require('./config.json')
 
@@ -10,10 +9,14 @@ const client = new Client({
 
 const cts = new CommandClient({
   owners: 'auto',
-  adapter: new DJSAdapter(client),
+  client,
   command: {
     prefix: '!',
   },
 })
 
+require('./modules/test')
+
+cts.registry.loadModulesIn('modules')
+
 client.login(config.token)

package/test/modules/test.ts

@@ -0,0 +1,44 @@
+import { command, CommandClient, Module, listener, rest } from '../../src'
+import { Message } from 'discord.js'
+
+class Test extends Module {
+  constructor(private client: CommandClient) {
+    super()
+  }
+
+  load() {
+    console.log('load')
+  }
+
+  unload() {
+    console.log('unload')
+  }
+
+  beforeReload() {
+    console.log('before reload')
+  }
+
+  afterReload() {
+    console.log('after reload')
+  }
+
+  @listener('ready')
+  ready() {
+    console.log(`Logged in as ${this.client.client.user!.tag}`)
+  }
+
+  @listener('commandError')
+  error(err: Error) {
+    console.error(err)
+  }
+
+  @command()
+  test(msg: Message, @rest asdf: string = 'wa sans') {
+    console.log(asdf)
+    msg.reply(asdf)
+  }
+}
+
+export function install(client: CommandClient) {
+  return new Test(client)
+}