@pikokr/command.ts 4.0.7 → 5.0.0-dev.645f87d

package/src/structures/CommandClient.ts

@@ -1,103 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import _ from 'lodash'
-import { Registry } from './Registry'
-import { Client, CommandInteraction, Interaction, Message, Snowflake, User } from 'discord.js'
-import { BuiltinCommandConverters, BuiltinApplicationCommandConverters, CommandHandler } from '../builtinModules'
-import { CoolDownAdapter, DefaultCoolDownAdapter } from '../command'
-import { Logger } from 'tslog'
-
-export interface CommandOptions {
-  prefix: string | ((msg: any) => string | Promise<string | string[]> | string[]) | string[]
-  check: (msg: Message) => boolean | Promise<boolean>
-}
-
-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 {
-  options: CommandClientOptions
-  owners: string[] = []
-  registry = new Registry(this)
-  client: Client
-  coolDownAdapter: CoolDownAdapter
-  logger: Logger
-
-  private _isReady = false
-
-  private async fetchOwners(): Promise<string[]> {
-    await this.client.application?.fetch()
-    const o = this.client.application?.owner
-    if (!o) return []
-    if (o instanceof User) return [o.id]
-    else return o.members.map((x) => x.id)
-  }
-
-  async ready() {
-    if (this._isReady) return
-    this._isReady = true
-    if (this.options.owners === 'auto') {
-      const owners = await this.fetchOwners()
-      this.owners.push(...owners)
-    }
-    if (this.options.applicationCommands.autoSync) {
-      await this.registry.syncCommands()
-    }
-  }
-
-  constructor({ client, coolDownAdapter, logger, ...options }: Partial<CommandClientOptionsParam> & { client: Client; coolDownAdapter?: CoolDownAdapter; logger?: Logger }) {
-    this.client = client
-    this.coolDownAdapter = coolDownAdapter || new DefaultCoolDownAdapter()
-    this.options = _.merge<CommandClientOptions, Partial<CommandClientOptionsParam>>(
-      {
-        command: {
-          prefix: '!',
-          check: () => true,
-        },
-        owners: 'auto',
-        slashCommands: {
-          check: () => true,
-        },
-        applicationCommands: {
-          autoSync: false,
-          beforeRunCheck: () => {},
-        },
-      },
-      options,
-    )
-
-    this.logger = logger ?? new Logger({ name: 'Command.TS' })
-
-    if (this.options.owners !== 'auto') {
-      this.owners = this.options.owners
-    }
-
-    this.client.once('ready', () => this.ready())
-    this.registry.registerModule(new CommandHandler(this.registry))
-    this.registry.registerModule(new BuiltinCommandConverters(this))
-    this.registry.registerModule(new BuiltinApplicationCommandConverters(this))
-  }
-}

package/src/structures/Module.ts

@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { KArgumentConverters, KCommands, KListeners, KMessageComponentHandlers, KModulePath, KSlashArgumentConverters, KApplicationCommands } from '../constants'
-import type { Command } from '../command'
-import { Listener } from '../listener'
-import { ArgumentConverter, ApplicationCommandArgumentConverter } from '../command'
-import { AppCommand } from '../applicationCommand'
-import { CommandClient } from './CommandClient'
-import { MessageComponentHandler } from '../messageComponents/base'
-
-export abstract class Module {
-  commandClient!: CommandClient
-
-  get logger() {
-    return this.commandClient.logger.getChildLogger({
-      name: this.constructor.name,
-    })
-  }
-
-  get commands(): Command[] {
-    return Reflect.getMetadata(KCommands, this) || []
-  }
-
-  get listeners(): Listener[] {
-    return Reflect.getMetadata(KListeners, this) || []
-  }
-
-  get argumentConverters(): ArgumentConverter[] {
-    return Reflect.getMetadata(KArgumentConverters, this) || []
-  }
-
-  get applicationCommandArgumentConverters(): ApplicationCommandArgumentConverter[] {
-    return Reflect.getMetadata(KSlashArgumentConverters, this) || []
-  }
-
-  get applicationCommands(): AppCommand[] {
-    return Reflect.getMetadata(KApplicationCommands, this) || []
-  }
-
-  get messageComponentHandlers(): MessageComponentHandler[] {
-    return Reflect.getMetadata(KMessageComponentHandlers, this) || []
-  }
-
-  get path(): string | undefined {
-    return Reflect.getMetadata(KModulePath, this)
-  }
-
-  load() {}
-  unload() {}
-  beforeReload() {}
-  afterReload() {}
-}

package/src/structures/Registry.ts

@@ -1,253 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { CommandClient } from './CommandClient'
-import { Module } from './Module'
-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 { AppCommand } from '../applicationCommand'
-import * as fs from 'fs'
-import { MessageComponentHandler } from '../messageComponents/base'
-
-type ListenerExecutor = {
-  event: string
-  execute: any
-}
-
-export class Registry {
-  constructor(public client: CommandClient) {}
-
-  modules: Collection<symbol, Module> = new Collection()
-
-  private get logger() {
-    return this.client.logger.getChildLogger({
-      name: 'Registry',
-    })
-  }
-
-  get commands(): Command[] {
-    const result: Command[] = []
-
-    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
-  }
-
-  get applicationCommandArgumentConverters(): ApplicationCommandArgumentConverter[] {
-    const result: ApplicationCommandArgumentConverter[] = []
-
-    for (const [, module] of this.modules) {
-      result.push(...module.applicationCommandArgumentConverters)
-    }
-
-    return result
-  }
-
-  get applicationCommands(): AppCommand[] {
-    const result: AppCommand[] = []
-
-    for (const [, module] of this.modules) {
-      result.push(...module.applicationCommands)
-    }
-
-    return result
-  }
-
-  get messageComponentHandlers(): MessageComponentHandler[] {
-    const result: MessageComponentHandler[] = []
-
-    for (const [, module] of this.modules) {
-      result.push(...module.messageComponentHandlers)
-    }
-
-    return result
-  }
-
-  registerModule(module: Module) {
-    module.commandClient = this.client
-
-    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)) {
-      if (fs.lstatSync(path.join(p, i)).isFile()) {
-        if (i.endsWith('.map')) continue
-        await this.loadModule(path.join(p, i), true)
-      }
-    }
-  }
-
-  async loadModule(file: string, absolute: boolean = false) {
-    let p = absolute ? file : path.join(require.main!.path, file)
-
-    let m
-
-    try {
-      m = require(p)
-    } catch (e: any) {
-      throw new ModuleLoadError(p, e)
-    }
-
-    if (m.loaded) throw new Error('MODULE_ALREADY_LOADED')
-
-    if (!m.install) throw new InvalidModuleError('Install function not found.')
-
-    const mod = m.install(this.client)
-
-    if (!(mod instanceof Module)) throw new InvalidTargetError()
-
-    Reflect.defineMetadata(KModulePath, require.resolve(p), mod)
-
-    this.registerModule(mod)
-
-    await mod.load()
-
-    m.loaded = true
-
-    return mod
-  }
-
-  async syncCommands() {
-    this.logger.debug(`Syncing commands...`)
-    const commands = this.applicationCommands.filter((x) => !x.guild)
-    const guild = this.client.options.applicationCommands.guild
-    const syncForGuild = async (g: Guild, commands: AppCommand[]) => {
-      this.logger.debug(`Syncing for guild ${g.name}(${g.id})`)
-      const commandsToRegister = commands.map((x) => x.command)
-      this.logger.debug(`Command List: ${commandsToRegister.map((x) => x.name).join(', ')}`)
-      await g.commands.set(commandsToRegister)
-    }
-    const commandsWithGuild = this.applicationCommands.filter((x) => !!x.guild)
-
-    if (guild) {
-      if (typeof guild === 'string') {
-        await syncForGuild(await this.client.client.guilds.fetch(guild), [
-          ...commands,
-          ...commandsWithGuild.filter((x) => x.guild && (typeof x.guild === 'string' ? guild === x.guild : x.guild.includes(guild))),
-        ])
-      } else {
-        for (const g of guild) {
-          await syncForGuild(await this.client.client.guilds.fetch(g), [
-            ...commands,
-            ...commandsWithGuild.filter((x) => x.guild && (typeof x.guild === 'string' ? g === x.guild : x.guild.includes(g))),
-          ])
-        }
-      }
-    } else {
-      this.logger.debug('Syncing global...')
-      await this.client.client.application?.commands.set(commands.map((x) => x.command))
-    }
-
-    const guilds = new Set<string>()
-
-    for (const command of commandsWithGuild) {
-      if (!command.guild) continue
-      if (typeof command.guild === 'string') {
-        guilds.add(command.guild)
-      } else {
-        for (const guild of command.guild) {
-          guilds.add(guild)
-        }
-      }
-    }
-
-    for (const guild of guilds) {
-      if (this.client.options.applicationCommands.guild?.includes(guild)) continue
-      await syncForGuild(
-        await this.client.client.guilds.fetch(guild),
-        commandsWithGuild.filter((x) => x.guild && (typeof x.guild === 'string' ? guild === x.guild : x.guild.includes(guild))),
-      )
-    }
-
-    this.logger.debug('Syncing ended.')
-  }
-
-  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
-  }
-
-  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]
-  }
-
-  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 && !Reflect.getMetadata(KBuiltInModule, x))) {
-      try {
-        await this.reloadModule(module)
-        results.push({
-          path: module.path!,
-          success: true,
-        })
-      } catch (e: any) {
-        results.push({
-          error: e,
-          path: module.path!,
-          success: false,
-        })
-      }
-    }
-    return results
-  }
-}

package/src/structures/index.ts

@@ -1,7 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-export * from './Module'
-export * from './CommandClient'
-export * from './Registry'

package/src/typings.ts

@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import type { Command } from './command'
-import { CommandClient } from './structures'
-import { AppCommand } from './applicationCommand'
-
-declare module 'discord.js' {
-  interface Message {
-    data: {
-      command: Command | null
-      prefix: string
-      cts: CommandClient
-    }
-  }
-  interface CommandInteraction {
-    data: {
-      command: AppCommand
-      cts: CommandClient
-    }
-  }
-  interface MessageComponentInteraction {
-    data: {
-      command: AppCommand
-      cts: CommandClient
-    }
-  }
-  interface ContextMenuInteraction {
-    data: {
-      command: AppCommand
-      cts: CommandClient
-    }
-  }
-}

package/src/utils.ts

@@ -1,10 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { Module } from './structures'
-import { InvalidTargetError } from './error'
-
-export const checkTarget = (target: Object) => {
-  if (!(target instanceof Module)) throw new InvalidTargetError()
-}

package/test/config.example.json

@@ -1,3 +0,0 @@
-{
-  "token": ""
-}

package/test/modules/dev.ts

@@ -1,44 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { BuiltInModule, CommandClient, ownerOnly, applicationCommand, listener, ApplicationCommandCheckFailed } from '../../dist'
-import { CommandInteraction } from 'discord.js'
-
-export class Dev extends BuiltInModule {
-  constructor(private cts: CommandClient) {
-    super()
-  }
-
-  @listener('slashCommandError')
-  slashError(e: Error, i: CommandInteraction) {
-    if (e instanceof ApplicationCommandCheckFailed) {
-      return i.reply({
-        content: 'Command before-run check failed',
-        ephemeral: true,
-      })
-    }
-    console.error(e.message)
-  }
-
-  // new SlashCommandBuilder().setName('reload').setDescription('리로드 커맨드')
-  @applicationCommand({
-    command: {
-      name: 'reload',
-      type: 'CHAT_INPUT',
-      description: '리로드 커맨드',
-    },
-  })
-  @ownerOnly
-  async reload(i: CommandInteraction) {
-    const data = await this.cts.registry.reloadAll()
-    await i.reply({
-      ephemeral: true,
-      content: '```\n' + data.map((x) => (x.success ? `✅ ${x.path}` : `❌ ${x.path}\n${x.error}`)).join('\n') + '```',
-    })
-  }
-}
-
-export function install(cts: CommandClient) {
-  return new Dev(cts)
-}

package/test/modules/test.ts

@@ -1,148 +0,0 @@
-/*
- * Copyright (c) 2022 pikokr. Licensed under the MIT license
- */
-
-import { CommandClient, coolDown, CoolDownError, CoolDownType, listener, messageButton, messageSelectMenu, Module, option, applicationCommand } from '../../dist'
-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')
-  }
-
-  unload() {
-    console.log('unload')
-  }
-
-  beforeReload() {
-    console.log('before reload')
-  }
-
-  afterReload() {
-    console.log('after reload')
-  }
-  // endregion
-
-  @listener('ready')
-  ready() {
-    console.log(`Logged in as ${this.client.client.user!.tag}`)
-  }
-
-  @listener('commandError')
-  error(err: Error, msg: Message) {
-    if (err instanceof CoolDownError) {
-      return msg.reply(`쿨다운: <t:${(err.endsAt.getTime() / 1000).toFixed(0)}:R>`)
-    }
-    console.error(err)
-  }
-  @listener('applicationCommandError')
-  slashCommandError(err: Error, msg: CommandInteraction | ContextMenuInteraction) {
-    if (err instanceof CoolDownError) {
-      return msg.reply({
-        content: `쿨다운: <t:${(err.endsAt.getTime() / 1000).toFixed(0)}:R>`,
-        ephemeral: true,
-      })
-    }
-    console.error(err)
-  }
-
-  @applicationCommand({
-    command: {
-      type: 'CHAT_INPUT',
-      name: 'test',
-      description: 'test',
-      options: [
-        {
-          type: 'STRING',
-          name: 'asdf',
-          description: 'test',
-        },
-      ],
-    },
-  })
-  @coolDown(CoolDownType.USER, 10)
-  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}`,
-    })
-  }
-
-  @applicationCommand({
-    command: {
-      type: 'USER',
-      name: 'contextMenuTest',
-      defaultPermission: true,
-    },
-  })
-  @coolDown(CoolDownType.USER, 10)
-  async contextMenuUser(i: UserContextMenuInteraction) {
-    return i.reply({
-      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: [],
-    })
-  }
-}
-
-export function install(client: CommandClient) {
-  return new Test(client)
-}