@pikokr/command.ts 5.0.0-dev.a9cbae8 → 5.0.0-dev.c0902b8

package/src/applicationCommand/ApplicationCommandExtension.ts

@@ -0,0 +1,169 @@
+/*
+* File: ApplicationCommandExtension.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import chalk from 'chalk'
+import {
+  ApplicationCommandData,
+  ApplicationCommandType,
+  ChatInputCommandInteraction,
+  Interaction,
+  InteractionType,
+  MessageContextMenuCommandInteraction,
+  Snowflake,
+  UserContextMenuCommandInteraction,
+} from 'discord.js'
+import { ApplicationCommandComponent } from './ApplicationCommand'
+import { ApplicationCommandOption } from './ApplicationCommandOption'
+import { moduleHook } from '../core/hooks'
+import { listener } from '../core/listener'
+import { CommandClient } from '../core/structures'
+import { argConverter } from '../core/converter'
+import { CTSExtension } from '../core/extensions/CTSExtension'
+
+export type ApplicationCommandExtensionConfig = {
+  guilds?: Snowflake[]
+}
+
+export class ApplicationCommandExtension extends CTSExtension {
+  constructor(public config: ApplicationCommandExtensionConfig) {
+    super()
+  }
+
+  @listener({ event: 'interactionCreate' })
+  async interactionCreate(i: Interaction) {
+    if (i.type !== InteractionType.ApplicationCommand) return
+
+    let cmd: ApplicationCommandComponent | null = null
+    let ext: object | null = null
+
+    const extensions = this.commandClient.registry.extensions
+
+    for (const extension of extensions) {
+      const components = this.commandClient.registry.getComponentsWithType(extension, ApplicationCommandComponent)
+
+      for (const command of components) {
+        if (command.options.name === i.commandName) {
+          ext = extension
+          cmd = command
+        }
+      }
+    }
+
+    if (cmd && ext) {
+      const argList: unknown[] = []
+
+      await this.convertArguments(ApplicationCommandComponent, argList, cmd.argTypes, () => [i])
+
+      for (const [idx, arg] of cmd.argTypes) {
+        let value: unknown = null
+
+        for (const decorator of arg.decorators) {
+          if (decorator instanceof ApplicationCommandOption) {
+            value = i.options.get(decorator.options.name, false)?.value
+            break
+          }
+        }
+
+        if (value) {
+          argList[idx] = value
+        }
+      }
+
+      try {
+        await cmd.execute(ext, argList, [i])
+      } catch (e) {
+        this.logger.error(e)
+        this.commandClient.emit('applicationCommandInvokeError', e, i)
+      }
+    }
+  }
+
+  @moduleHook('load')
+  async load() {}
+
+  async sync() {
+    const client = CommandClient.getFromModule(this)
+
+    this.logger.info('Trying to sync commands...')
+
+    const commands: ApplicationCommandData[] = []
+
+    for (const command of client.registry.getComponentsWithTypeGlobal(ApplicationCommandComponent)) {
+      const cmd: ApplicationCommandData = { ...command.options }
+
+      if (cmd.type === ApplicationCommandType.ChatInput) {
+        cmd.options = []
+
+        for (const [, arg] of command.argTypes) {
+          const option = arg.decorators.find((x) => x.constructor === ApplicationCommandOption) as ApplicationCommandOption
+
+          if (option) {
+            cmd.options.push(option.options)
+          }
+        }
+      }
+
+      commands.push(cmd)
+    }
+
+    this.logger.info(`Processing ${chalk.green(commands.length)} commands(${commands.map((x) => chalk.blue(x.name)).join(', ')})`)
+
+    if (this.config.guilds) {
+      for (const guild of this.config.guilds) {
+        try {
+          const g = await this.client.guilds.fetch(guild)
+          await g.fetch()
+          this.logger.info(`Registering commands for guild ${chalk.green(g.name)}(${chalk.blue(g.id)})`)
+
+          await g.commands.set(commands)
+
+          this.logger.info(`Successfully registered commands for guild ${chalk.green(g.name)}(${chalk.blue(g.id)})`)
+        } catch (e) {
+          this.logger.error(`Failed to register commands to guild ${chalk.green(guild)}: ${(e as Error).message}`)
+        }
+      }
+    } else {
+      try {
+        this.logger.info(`Registering commands globally...`)
+
+        await this.client.application!.commands.set(commands)
+
+        this.logger.info('Successfully registered commands.')
+      } catch (e) {
+        this.logger.error(`Failed to register commands to global: ${(e as Error).message}`)
+      }
+    }
+  }
+
+  @argConverter({
+    component: ApplicationCommandComponent,
+    parameterless: true,
+    type: ChatInputCommandInteraction,
+  })
+  async chatInteraction(i: ChatInputCommandInteraction) {
+    return i
+  }
+
+  @argConverter({
+    component: ApplicationCommandComponent,
+    parameterless: true,
+    type: MessageContextMenuCommandInteraction,
+  })
+  async messageInteraction(i: MessageContextMenuCommandInteraction) {
+    return i
+  }
+
+  @argConverter({
+    component: ApplicationCommandComponent,
+    parameterless: true,
+    type: UserContextMenuCommandInteraction,
+  })
+  async userInteraction(i: UserContextMenuCommandInteraction) {
+    return i
+  }
+}

package/src/applicationCommand/ApplicationCommandOption.ts

@@ -1,6 +1,13 @@
+/*
+* File: ApplicationCommandOption.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
 import { APIApplicationCommandOption } from 'discord.js'
-import { createArgumentDecorator } from '../core'
-import { ComponentArgumentDecorator } from '../core/components/ComponentArgumentDecorator'
+import { createArgumentDecorator, ComponentArgumentDecorator } from '../core'
 
 type Options = APIApplicationCommandOption
 

package/src/applicationCommand/index.ts

@@ -1,2 +1,10 @@
-export { applicationCommand } from './ApplicationCommand'
+/*
+* File: index.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+export * from './ApplicationCommand'
 export { option } from './ApplicationCommandOption'

package/src/core/components/BaseComponent.ts

@@ -1,20 +1,28 @@
+/*
+* File: BaseComponent.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
 import { Collection } from 'discord.js'
 import _ from 'lodash'
+import type { ComponentHookStore } from '../hooks'
 import { ComponentArgument } from './ComponentArgument'
 
-export class BaseComponent<Options = unknown> {
+export class BaseComponent<Options = unknown, OptionsArg = Options> {
   options: Options
 
   method: Function
 
+  hooks: ComponentHookStore = new Collection()
+
   argTypes: Collection<number, ComponentArgument> = new Collection()
 
-  constructor(options: Partial<Options>, method: Function, argTypes: unknown[]) {
-    if (typeof options === 'object') {
-      this.options = _.merge(this.defaultOptions(), options)
-    } else {
-      this.options = options
-    }
+  constructor(options: OptionsArg, method: Function, argTypes: unknown[]) {
+    this.options = this.convertOptions(options)
+
     this.method = method
     for (let i = 0; i < argTypes.length; i++) {
       const element = argTypes[i]
@@ -22,11 +30,33 @@ export class BaseComponent<Options = unknown> {
     }
   }
 
-  defaultOptions(): Options {
-    return ({} as unknown) as Options
+  convertOptions(options: OptionsArg): Options {
+    return options as unknown as Options
   }
 
-  execute(target: object, args: unknown[]) {
-    return this.method.apply(target, args)
+  async executeHook(target: object, name: string, args: unknown[]) {
+    const hook = this.hooks.get(name)
+
+    if (!hook) return
+
+    const { CommandClient } = await import('../structures/CommandClient')
+
+    for (const fn of hook) {
+      await fn.call(null, CommandClient.getFromModule(target), ...args)
+    }
+  }
+
+  async execute(target: object, args: unknown[], beforeCallArgs: unknown[] = args) {
+    await this.executeHook(target, 'beforeCall', beforeCallArgs)
+    let result
+    try {
+      result = await this.method.call(target, ...args)
+    } catch (e) {
+      await this.executeHook(target, 'invokeError', [e])
+      throw e
+    }
+    await this.executeHook(target, 'afterCall', [result])
+
+    return result
   }
 }

package/src/core/components/ComponentArgument.ts

@@ -1,3 +1,11 @@
+/*
+* File: ComponentArgument.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
 import { ComponentArgumentDecorator } from './ComponentArgumentDecorator'
 
 export class ComponentArgument {

package/src/core/components/ComponentArgumentDecorator.ts

@@ -1,3 +1,11 @@
+/*
+* File: ComponentArgumentDecorator.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
 import _ from 'lodash'
 
 export class ComponentArgumentDecorator<Options = unknown> {
@@ -12,6 +20,6 @@ export class ComponentArgumentDecorator<Options = unknown> {
   }
 
   defaultOptions(): Options {
-    return ({} as unknown) as Options
+    return {} as unknown as Options
   }
 }

package/src/core/components/decoratorCreator.ts

@@ -1,14 +1,23 @@
+/*
+* File: decoratorCreator.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
 import { Collection } from 'discord.js'
+import { ComponentHookStore } from '../hooks'
+import { getComponentHookStore } from '../hooks/componentHook'
 import { ComponentStoreSymbol } from '../symbols'
 import { BaseComponent } from './BaseComponent'
-import { ComponentArgument } from './ComponentArgument'
 import { ComponentArgumentDecorator } from './ComponentArgumentDecorator'
 
-type ComponentStore = Collection<string|symbol, BaseComponent>
+type ComponentStore = Collection<string | symbol, BaseComponent>
 type ComponentArgumentStore = Collection<number, ComponentArgumentDecorator>
 
 export const getComponentStore = (target: object): ComponentStore => {
-  let result: ComponentStore|null = Reflect.getMetadata(ComponentStoreSymbol, target)
+  let result: ComponentStore | null = Reflect.getMetadata(ComponentStoreSymbol, target)
 
   if (!result) {
     result = new Collection()
@@ -19,22 +28,26 @@ export const getComponentStore = (target: object): ComponentStore => {
   return result
 }
 
-export const getComponent = (target: object, key: string|symbol) => {
+export const getComponent = (target: object, key: string | symbol) => {
   const store = getComponentStore(target)
 
   return store.get(key)
 }
 
-export const createComponentDecorator = <Options>(type: typeof BaseComponent<Options>) => {
-  return (options: Options): MethodDecorator => {
+export const createComponentDecorator = <Options, OptionArgs>(type: typeof BaseComponent<Options, OptionArgs>) => {
+  return (options: OptionArgs): MethodDecorator => {
     return (target, key) => {
-      var component: BaseComponent<Options> = new type(options, Reflect.get(target, key), Reflect.getMetadata('design:paramtypes', target, key))
+      var component: BaseComponent<Options, OptionArgs> = new type(options, Reflect.get(target, key), Reflect.getMetadata('design:paramtypes', target, key))
+
+      const componentHookStore: ComponentHookStore = getComponentHookStore(target, key)
+
+      component.hooks = componentHookStore
 
       const store = getComponentStore(target)
 
       const decorators = getComponentArgumentStore(target, key)
 
-      decorators.forEach((x, i)=> {
+      decorators.forEach((x, i) => {
         component.argTypes.get(i)?.decorators.push(x)
       })
 
@@ -43,8 +56,8 @@ export const createComponentDecorator = <Options>(type: typeof BaseComponent<Opt
   }
 }
 
-export const getComponentArgumentStore = (target: object, key: string|symbol): ComponentArgumentStore => {
-  let result: ComponentArgumentStore|null = Reflect.getMetadata(ComponentStoreSymbol, target, key)
+export const getComponentArgumentStore = (target: object, key: string | symbol): ComponentArgumentStore => {
+  let result: ComponentArgumentStore | null = Reflect.getMetadata(ComponentStoreSymbol, target, key)
 
   if (!result) {
     result = new Collection()
@@ -66,4 +79,3 @@ export const createArgumentDecorator = <Options>(type: typeof ComponentArgumentD
     }
   }
 }
-

package/src/core/components/index.ts

@@ -1,3 +1,13 @@
-import 'reflect-metadata'
-export * from './BaseComponent'
-export * from './decoratorCreator'
+/*
+* File: index.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import 'reflect-metadata'
+export * from './decoratorCreator'
+export * from './ComponentArgument'
+export * from './ComponentArgumentDecorator'
+export * from './BaseComponent'

package/src/core/converter/index.ts

@@ -0,0 +1,16 @@
+/*
+* File: index.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import { BaseComponent } from '../components/BaseComponent'
+import { createComponentDecorator } from '../components/decoratorCreator'
+
+type Options = { component: typeof BaseComponent<unknown>; type: Function; parameterless: boolean }
+
+export class ConverterComponent extends BaseComponent<Options, Omit<Options, 'parameterless'> & { parameterless?: boolean }> {}
+
+export const argConverter = createComponentDecorator(ConverterComponent)

package/src/core/extensions/CTSExtension.ts

@@ -0,0 +1,17 @@
+/*
+* File: CTSExtension.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import chalk from 'chalk'
+import { Extension } from './Extension'
+
+export class CTSExtension extends Extension {
+  protected get logger() {
+    if (!this._logger) this._logger = this.commandClient.ctsLogger.getChildLogger({ prefix: [chalk.green(`[${this.constructor.name}]`)], displayFunctionName: false })
+    return this._logger
+  }
+}

package/src/core/extensions/Extension.ts

@@ -0,0 +1,62 @@
+/*
+* File: Extension.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import chalk from 'chalk'
+import { Collection } from 'discord.js'
+import { Logger } from 'tslog'
+import { BaseComponent } from '../components'
+import { ComponentArgument } from '../components/ComponentArgument'
+import { ConverterComponent } from '../converter'
+import { CommandClient } from '../structures'
+
+export class Extension {
+  protected get commandClient() {
+    return CommandClient.getFromModule(this)
+  }
+
+  protected get client() {
+    return this.commandClient.discord
+  }
+
+  protected _logger?: Logger
+
+  protected get logger() {
+    if (!this._logger) this._logger = this.commandClient.logger.getChildLogger({ prefix: [chalk.green(`[${this.constructor.name}]`)], displayFunctionName: false })
+    return this._logger
+  }
+
+  protected async convertArguments(
+    component: typeof BaseComponent<unknown>,
+    argList: unknown[],
+    args: Collection<number, ComponentArgument>,
+    getConverterArgs: (arg: ComponentArgument, index: number, converter: ConverterComponent) => unknown[] | Promise<unknown[]>,
+  ) {
+    const items = new Collection<unknown, { ext: object; component: ConverterComponent }>()
+
+    for (const extension of this.commandClient.registry.extensions) {
+      for (const converter of this.commandClient.registry.getComponentsWithType(extension, ConverterComponent)) {
+        if (converter.options.component != component) continue
+
+        items.set(converter.options.type, { component: converter, ext: extension })
+      }
+    }
+
+    for (const [index, arg] of args) {
+      const converter = items.get(arg.type)
+
+      if (!converter) {
+        argList[index] = undefined
+        continue
+      }
+
+      const converterArgs = await getConverterArgs(arg, index, converter.component)
+
+      argList[index] = await converter.component.execute(converter.ext, converterArgs)
+    }
+  }
+}

package/src/core/extensions/index.ts

@@ -0,0 +1,9 @@
+/*
+* File: index.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+export * from './Extension'

package/src/core/hooks/componentHook.ts

@@ -0,0 +1,40 @@
+/*
+* File: componentHook.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import { Collection } from 'discord.js'
+import { ComponentHookSymbol } from '../symbols'
+
+export type ComponentHookFn = (...args: any[]) => void | Promise<void>
+
+export type ComponentHookStore = Collection<string, ComponentHookFn[]>
+
+export const getComponentHookStore = (target: object, property: string | symbol): ComponentHookStore => {
+  let data = Reflect.getMetadata(ComponentHookSymbol, target, property) as ComponentHookStore
+
+  if (!data) {
+    data = new Collection()
+    Reflect.defineMetadata(ComponentHookSymbol, data, target, property)
+  }
+
+  return data
+}
+
+export const createComponentHook = (name: string, fn: ComponentHookFn): MethodDecorator => {
+  return (target, key) => {
+    const store = getComponentHookStore(target, key)
+
+    let hooks = store.get(name)
+
+    if (!hooks) {
+      hooks = []
+      store.set(name, hooks)
+    }
+
+    hooks.push(fn)
+  }
+}

package/src/core/hooks/index.ts

@@ -0,0 +1,11 @@
+/*
+* File: index.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+export * from './moduleHook'
+export { createComponentHook } from './componentHook'
+export type { ComponentHookStore } from './componentHook'

package/src/core/hooks/moduleHook.ts

@@ -0,0 +1,39 @@
+/*
+* File: moduleHook.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import { Collection } from 'discord.js'
+import { ModuleHookStoreSymbol } from '../symbols'
+
+type ModuleHookStore = Collection<string, Function[]>
+
+export const getModuleHookStore = (target: object) => {
+  let result: ModuleHookStore | null = Reflect.getMetadata(ModuleHookStoreSymbol, target)
+
+  if (!result) {
+    result = new Collection()
+
+    Reflect.defineMetadata(ModuleHookStoreSymbol, result, target)
+  }
+
+  return result
+}
+
+export const moduleHook = (name: string): MethodDecorator => {
+  return (target, key) => {
+    const store = getModuleHookStore(target)
+
+    let v = store.get(name)
+
+    if (!v) {
+      v = []
+      store.set(name, v)
+    }
+
+    v.push(Reflect.get(target, key))
+  }
+}

package/src/core/index.ts

@@ -1 +1,15 @@
+/*
+* File: index.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
 export * from './components'
+export * from './hooks'
+export * from './converter'
+export * from './utils'
+export * from './listener'
+export * from './structures'
+export * from './extensions'

package/src/core/listener/index.ts

@@ -0,0 +1,29 @@
+/*
+* File: index.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import { BaseComponent } from '../components/BaseComponent'
+import { createComponentDecorator } from '../components/decoratorCreator'
+
+export class ListenerComponent extends BaseComponent<{ emitter: string; event: string }, { emitter?: string; event: string }> {
+  defaultOptions() {
+    return { emitter: 'discord' }
+  }
+
+  constructor(options: ListenerComponent['options'], method: Function, argTypes: unknown[]) {
+    super(
+      {
+        event: options.event,
+        emitter: options.emitter ?? 'discord',
+      },
+      method,
+      argTypes,
+    )
+  }
+}
+
+export const listener = createComponentDecorator(ListenerComponent)