@pikokr/command.ts 4.0.7 → 5.0.0-dev.144e990

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

@@ -0,0 +1,16 @@
+/*
+* 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, ComponentArgumentDecorator } from '../core'
+
+type Options = APIApplicationCommandOption
+
+export class ApplicationCommandOption extends ComponentArgumentDecorator<Options> {}
+
+export const option = createArgumentDecorator(ApplicationCommandOption)

package/src/applicationCommand/index.ts

@@ -1,6 +1,10 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-export * from './decorator'
-export * from './AppCommand'
+/*
+* 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

@@ -0,0 +1,62 @@
+/*
+* 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, OptionsArg = Options> {
+  options: Options
+
+  method: Function
+
+  hooks: ComponentHookStore = new Collection()
+
+  argTypes: Collection<number, ComponentArgument> = new Collection()
+
+  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]
+      this.argTypes.set(i, new ComponentArgument(element))
+    }
+  }
+
+  convertOptions(options: OptionsArg): Options {
+    return options as unknown as Options
+  }
+
+  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

@@ -0,0 +1,15 @@
+/*
+* 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 {
+  decorators: ComponentArgumentDecorator[] = []
+
+  constructor(public type: unknown) {}
+}

package/src/core/components/ComponentArgumentDecorator.ts

@@ -0,0 +1,25 @@
+/*
+* 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> {
+  options: Options
+
+  constructor(options: Partial<Options>) {
+    if (typeof options === 'object') {
+      this.options = _.merge(this.defaultOptions(), options)
+    } else {
+      this.options = options
+    }
+  }
+
+  defaultOptions(): Options {
+    return {} as unknown as Options
+  }
+}

package/src/core/components/decoratorCreator.ts

@@ -0,0 +1,81 @@
+/*
+* 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 { ComponentArgumentDecorator } from './ComponentArgumentDecorator'
+
+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)
+
+  if (!result) {
+    result = new Collection()
+
+    Reflect.defineMetadata(ComponentStoreSymbol, result, target)
+  }
+
+  return result
+}
+
+export const getComponent = (target: object, key: string | symbol) => {
+  const store = getComponentStore(target)
+
+  return store.get(key)
+}
+
+export const createComponentDecorator = <Options, OptionArgs>(type: typeof BaseComponent<Options, OptionArgs>) => {
+  return (options: OptionArgs): MethodDecorator => {
+    return (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) => {
+        component.argTypes.get(i)?.decorators.push(x)
+      })
+
+      store.set(key, component)
+    }
+  }
+}
+
+export const getComponentArgumentStore = (target: object, key: string | symbol): ComponentArgumentStore => {
+  let result: ComponentArgumentStore | null = Reflect.getMetadata(ComponentStoreSymbol, target, key)
+
+  if (!result) {
+    result = new Collection()
+
+    Reflect.defineMetadata(ComponentStoreSymbol, result, target, key)
+  }
+
+  return result
+}
+
+export const createArgumentDecorator = <Options>(type: typeof ComponentArgumentDecorator<Options>) => {
+  return (options: Options): ParameterDecorator => {
+    return (target, key, idx) => {
+      var arg: ComponentArgumentDecorator<Options> = new type(options)
+
+      const store = getComponentArgumentStore(target, key)
+
+      store.set(idx, arg)
+    }
+  }
+}

package/src/core/components/index.ts

@@ -0,0 +1,13 @@
+/*
+* 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

@@ -0,0 +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)