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

package/src/builtinModules/CommandHandler.ts

@@ -0,0 +1,120 @@
+import { BuiltInModule } from './BuiltInModule'
+import { Registry } from '../structures'
+import { listener } from '../listener'
+import { Message } from 'discord.js'
+import { CommandClient } from '../structures'
+import { Command } from '../command'
+import { ArgumentConverterNotFound, ArgumentNotProvided, CommandCheckFailed } from '../error'
+import { CommandNotFound } from '../error/CommandNotFound'
+
+export class CommandHandler extends BuiltInModule {
+  private client: CommandClient
+
+  constructor(private registry: Registry) {
+    super()
+    this.client = registry.client
+  }
+
+  @listener('messageCreate')
+  async message(msg: Message) {
+    const error = (error: Error) => this.client.client.emit('commandError', error, msg)
+
+    try {
+      const prefixList: string[] | string =
+        typeof this.client.options.command.prefix === 'string'
+          ? this.client.options.command.prefix
+          : typeof this.client.options.command.prefix === 'function'
+          ? await this.client.options.command.prefix(msg)
+          : this.client.options.command.prefix
+      let prefix: string
+      if (typeof prefixList === 'object') {
+        const res = prefixList.find((x) => msg.content.includes(x))
+
+        if (!res) return
+
+        prefix = res
+      } else {
+        if (!msg.content.includes(prefixList)) return
+        prefix = prefixList
+      }
+
+      if (!msg.content.startsWith(prefix)) return
+
+      const args = msg.content.slice(prefix.length).split(' ')
+
+      const command = args.shift()
+
+      if (!command) return
+
+      let cmd: Command | null = null
+
+      for (const c of this.registry.commands) {
+        if (c.name === command) {
+          cmd = c
+          break
+        }
+        if ((typeof c.aliases === 'function' ? await c.aliases(msg) : c.aliases).includes(command)) {
+          cmd = c
+          break
+        }
+      }
+
+      if (!cmd) return error(new CommandNotFound(command))
+
+      msg.data = {
+        cts: this.client,
+        command: cmd,
+        prefix: prefix,
+      }
+
+      const module = this.registry.modules.find((x) => x.commands.includes(cmd!))
+
+      if (!module) return
+
+      const argList: any[] = []
+
+      for (const check of cmd.checks) {
+        if (!(await check(msg))) return error(new CommandCheckFailed(msg, cmd))
+      }
+
+      for (let i = 0; i < cmd.argTypes.length; i++) {
+        const argType = cmd.argTypes[i]
+        const converter = this.registry.argumentConverters.find((x) => x.type === argType.type)
+
+        if (argType.rest) {
+          const i = args.join(' ')
+          if (!i) break
+          argList.push(i)
+          break
+        }
+
+        if (!converter) return error(new ArgumentConverterNotFound(argType, msg))
+
+        if (converter.withoutParameter) {
+          argList.push(await converter.execute(module, msg))
+          continue
+        }
+        const arg = args.shift()
+        if (argType.optional && !arg) {
+          break
+        }
+        if (!arg) {
+          return error(new ArgumentNotProvided(i, cmd, msg))
+        }
+        const executed = await converter.execute(module, msg, arg)
+        if (!executed === undefined) {
+          return error(new ArgumentNotProvided(i, cmd, msg))
+        }
+        argList.push(executed)
+      }
+
+      try {
+        cmd.execute(module, argList)
+      } catch (e: any) {
+        return error(e)
+      }
+    } catch (e) {
+      return error(e)
+    }
+  }
+}

package/src/builtinModules/index.ts

@@ -0,0 +1,2 @@
+export * from './CommandHandler'
+export * from './BuiltinCommandConverters'

package/src/command/ArgumentConverter.ts

@@ -0,0 +1,10 @@
+import { Module } from '../structures'
+import { Message } from 'discord.js'
+
+export class ArgumentConverter {
+  execute(module: Module, msg: Message, arg?: string) {
+    return this.run.apply(module, [msg, arg])
+  }
+
+  constructor(public type: object, private run: Function, public withoutParameter: boolean) {}
+}

package/src/command/Command.ts

@@ -1,15 +1,30 @@
 import { Module } from '../structures'
+import { Message } from 'discord.js'
+import { KCommandChecks } from '../constants'
+
+export type Argument = {
+  optional: boolean
+  type: any
+  rest: boolean
+}
+
+export type CheckFunction = (msg: Message) => boolean | Promise<boolean>
 
 export class Command {
-  execute(args: string[]) {
-    return this.run.call(this.module, args)
+  execute(module: Module, args: any[]) {
+    return this.run.apply(module, args)
+  }
+
+  get checks(): CheckFunction[] {
+    return Reflect.getMetadata(KCommandChecks, this.module, this.key) || []
   }
 
   constructor(
-    public module: Module,
     private run: Function,
-    public argTypes: any[],
+    public argTypes: Argument[],
     public name: string,
-    public aliases: string[],
+    public aliases: string[] | ((msg: Message) => string[]),
+    public module: Module,
+    public key: symbol | string,
   ) {}
 }

package/src/command/decorator.ts

@@ -1,18 +1,18 @@
-import { KCommands } from '../constants'
-import { Module } from '../structures'
-import { InvalidTargetError } from '../error'
+import { KArgumentConverters, KCommands, KOptionals, KRest } from '../constants'
 import { Command } from './Command'
+import { checkTarget } from '../utils'
+import { ArgumentConverter } from './ArgumentConverter'
+import { Module } from '../structures'
+import { createCheckDecorator } from './utils'
+import { Message, PermissionResolvable, Permissions, TextChannel } from 'discord.js'
+import { ClientPermissionRequired, UserPermissionRequired } from '../error'
 
 type CommandOptions = {
   name: string
-  aliases: string[]
+  aliases: string[] | ((msg: Message) => string[])
 }
 
-const checkTarget = (target: Object) => {
-  if (!(target instanceof Module)) throw new InvalidTargetError()
-}
-
-export const command = (options: Partial<CommandOptions>) => {
+export const command = (options: Partial<CommandOptions> = {}) => {
   return (
     target: Object,
     propertyKey: string,
@@ -22,14 +22,23 @@ export const command = (options: Partial<CommandOptions>) => {
 
     let properties: Command[] = Reflect.getMetadata(KCommands, target)
 
-    const params = Reflect.getMetadata('design:paramtypes', target, propertyKey)
+    const params: any[] = Reflect.getMetadata('design:paramtypes', target, propertyKey)
+
+    const optionals: number = Reflect.getMetadata(KOptionals, target, propertyKey) || -1
+
+    const rest = Reflect.getMetadata(KRest, target, propertyKey) || -1
 
     const command = new Command(
-      target as Module,
       Reflect.get(target, propertyKey),
-      params,
+      params.map((x, i) => ({
+        type: x,
+        optional: optionals === -1 ? false : optionals <= i,
+        rest: rest === -1 ? false : rest === i,
+      })),
       options.name || propertyKey,
       options.aliases || [],
+      target as Module,
+      propertyKey,
     )
 
     if (properties) {
@@ -40,3 +49,66 @@ export const command = (options: Partial<CommandOptions>) => {
     }
   }
 }
+
+export const argumentConverter = (type: object, requireParameter = true) => {
+  return (
+    target: Object,
+    propertyKey: string,
+    // descriptor: TypedPropertyDescriptor<any>,
+  ) => {
+    checkTarget(target)
+
+    let properties: ArgumentConverter[] = Reflect.getMetadata(KArgumentConverters, target)
+
+    const converter = new ArgumentConverter(type, Reflect.get(target, propertyKey), !requireParameter)
+
+    if (properties) {
+      properties.push(converter)
+    } else {
+      properties = [converter]
+      Reflect.defineMetadata(KArgumentConverters, properties, target)
+    }
+  }
+}
+
+export const optional: ParameterDecorator = (target, propertyKey, parameterIndex) => {
+  checkTarget(target)
+
+  Reflect.defineMetadata(KOptionals, parameterIndex, target, propertyKey)
+}
+
+export const rest: ParameterDecorator = (target, propertyKey, parameterIndex) => {
+  checkTarget(target)
+
+  const params: any[] = Reflect.getMetadata('design:paramtypes', target, propertyKey)
+
+  if (params.length - 1 !== parameterIndex) throw new Error('Rest decorator must be used at last argument.')
+
+  if (params[parameterIndex] !== String) throw new Error('Rest argument type must be "String"')
+
+  Reflect.defineMetadata(KRest, parameterIndex, target, propertyKey)
+}
+
+export const ownerOnly = createCheckDecorator((msg) => msg.data.cts.owners.includes(msg.author.id))
+
+export const guildOnly = createCheckDecorator((msg) => !!msg.guild)
+
+export const dmOnly = createCheckDecorator((msg) => !msg.guild)
+
+export const requireUserPermissions = (permission: PermissionResolvable) =>
+  createCheckDecorator((msg) => {
+    if (!msg.guild || !msg.member) throw new Error('This command must be used in serer.')
+    if (msg.member.permissionsIn(msg.channel as TextChannel).has(permission)) {
+      return true
+    }
+    throw new UserPermissionRequired(msg.member, new Permissions(permission))
+  })
+
+export const requireClientPermissions = (permission: PermissionResolvable) =>
+  createCheckDecorator((msg) => {
+    if (!msg.guild) throw new Error('This command must be used in serer.')
+    if (msg.guild.me!.permissionsIn(msg.channel as TextChannel).has(permission)) {
+      return true
+    }
+    throw new ClientPermissionRequired(new Permissions(permission))
+  })

package/src/command/index.ts

@@ -1,2 +1,4 @@
 export * from './Command'
 export * from './decorator'
+export * from './ArgumentConverter'
+export * from './utils'

package/src/command/utils.ts

@@ -0,0 +1,15 @@
+import { Message } from 'discord.js'
+import type { CheckFunction } from './Command'
+import { KCommandChecks } from '../constants'
+
+export const createCheckDecorator = (execute: (msg: Message) => boolean | Promise<boolean>): MethodDecorator => {
+  return (target, propertyKey) => {
+    let properties: CheckFunction[] = Reflect.getMetadata(KCommandChecks, target, propertyKey)
+    if (properties) {
+      properties.push(execute)
+    } else {
+      properties = [execute]
+      Reflect.defineMetadata(KCommandChecks, properties, target, propertyKey)
+    }
+  }
+}

package/src/constants.ts

@@ -1,3 +1,17 @@
-export const KCommands = Symbol('Command.TS Command')
+export const KCommands = Symbol('Command.TS Commands')
+
+export const KListeners = Symbol('Command.TS Listeners')
 
 export const KModulePath = Symbol('Command.TS Module Path')
+
+export const KListenerExecuteCache = Symbol('Command.TS Module Identifier')
+
+export const KBuiltInModule = Symbol('Command.TS Built-In Module')
+
+export const KOptionals = Symbol('Command.TS Optional Parameters')
+
+export const KRest = Symbol('Command.TS Rest Parameter')
+
+export const KArgumentConverters = Symbol('Command.TS Argument Converter')
+
+export const KCommandChecks = Symbol('Command.TS Command Checks')

package/src/error/ArgumentConverterNotFound.ts

@@ -0,0 +1,8 @@
+import { Message } from 'discord.js'
+import type { Argument } from '../command'
+
+export class ArgumentConverterNotFound extends Error {
+  constructor(public type: Argument, public msg: Message) {
+    super(`Argument converter ${type.type.name} not found.`)
+  }
+}

package/src/error/ArgumentNotProvided.ts

@@ -0,0 +1,8 @@
+import { Message } from 'discord.js'
+import { Command } from '../command'
+
+export class ArgumentNotProvided extends Error {
+  constructor(public index: number, public command: Command, public msg: Message) {
+    super(`Required argument #${index} not provided.`)
+  }
+}

package/src/error/CommandCheckFailed.ts

@@ -0,0 +1,8 @@
+import { Message } from 'discord.js'
+import { Command } from '../command'
+
+export class CommandCheckFailed extends Error {
+  constructor(public msg: Message, public command: Command) {
+    super()
+  }
+}

package/src/error/CommandNotFound.ts

@@ -0,0 +1,5 @@
+export class CommandNotFound extends Error {
+  constructor(public commandName: string) {
+    super(`Command ${commandName} not found.`)
+  }
+}

package/src/error/ModuleError.ts

@@ -0,0 +1,7 @@
+export class ModuleLoadError extends Error {
+  constructor(file: string) {
+    super('Failed to load module ' + file)
+  }
+}
+
+export class InvalidModuleError extends Error {}

package/src/error/PermissionRequired.ts

@@ -0,0 +1,13 @@
+import { GuildMember, Permissions } from 'discord.js'
+
+export class UserPermissionRequired extends Error {
+  constructor(public user: GuildMember, public permissions: Permissions) {
+    super()
+  }
+}
+
+export class ClientPermissionRequired extends Error {
+  constructor(public permissions: Permissions) {
+    super()
+  }
+}

package/src/error/index.ts

@@ -1 +1,6 @@
 export * from './InvalidTargetError'
+export * from './ModuleError'
+export * from './ArgumentNotProvided'
+export * from './ArgumentConverterNotFound'
+export * from './CommandCheckFailed'
+export * from './PermissionRequired'

package/src/index.ts

@@ -1,6 +1,9 @@
 import 'reflect-metadata'
+import './typings'
 
 export * from './interface'
 export * from './structures'
 export * from './error'
 export * from './command'
+export * from './listener'
+export * from './builtinModules/BuiltInModule'

package/src/interface/index.ts

@@ -1 +1,3 @@
-export type { HandlerAdapter } from './HandlerAdapter'
+// export type { HandlerAdapter } from './HandlerAdapter'
+
+export {}

package/src/listener/Listener.ts

@@ -0,0 +1,3 @@
+export class Listener {
+  constructor(public name: string, public execute: Function) {}
+}

package/src/listener/decorator.ts

@@ -0,0 +1,25 @@
+import { checkTarget } from '../utils'
+import { KListeners } from '../constants'
+import { Listener } from './Listener'
+import { Module } from '../structures'
+
+export const listener = (event: string) => {
+  return (
+    target: Module,
+    propertyKey: string,
+    // descriptor: TypedPropertyDescriptor<any>,
+  ) => {
+    checkTarget(target)
+
+    let properties: Listener[] = Reflect.getMetadata(KListeners, target)
+
+    const listener = new Listener(event, Reflect.get(target, propertyKey))
+
+    if (properties) {
+      properties.push(listener)
+    } else {
+      properties = [listener]
+      Reflect.defineMetadata(KListeners, properties, target)
+    }
+  }
+}

package/src/listener/index.ts

@@ -0,0 +1,2 @@
+export * from './Listener'
+export * from './decorator'

package/src/structures/CommandClient.ts

@@ -1,12 +1,10 @@
-import { HandlerAdapter } from '../interface'
 import _ from 'lodash'
 import { Registry } from './Registry'
+import { Client, Message, User } from 'discord.js'
+import { BuiltinCommandConverters, CommandHandler } from '../builtinModules'
 
 export interface CommandOptions {
-  prefix:
-    | string
-    | ((msg: any) => string | Promise<string | string[]> | string[])
-    | string[]
+  prefix: string | ((msg: any) => string | Promise<string | string[]> | string[]) | string[]
 }
 
 export interface CommandClientOptions {
@@ -20,66 +18,40 @@ export interface CommandClientOptionsParam {
 }
 
 export class CommandClient {
-  adapter: HandlerAdapter<any>
   options: CommandClientOptions
   owners: string[] = []
   registry = new Registry(this)
+  client: Client
 
-  async handle(msg: any) {
-    const data = this.adapter.getCommandData(msg)
-    const prefixList: string[] | string =
-      typeof this.options.command.prefix === 'string'
-        ? this.options.command.prefix
-        : typeof this.options.command.prefix === 'function'
-        ? await this.options.command.prefix(msg)
-        : this.options.command.prefix
-    let prefix: string
-    if (typeof prefixList === 'object') {
-      const res = prefixList.find((x) => data.content.includes(x))
-
-      if (!res) return
-
-      prefix = res
-    } else {
-      if (!data.content.includes(prefixList)) return
-      prefix = prefixList
-    }
-
-    const args = data.content.slice(prefix.length).split(' ')
-
-    const command = args.shift()
-
-    if (!command) return
+  private _isReady = false
 
-    console.log(command)
-    console.log(args)
+  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)
   }
 
-  private _isReady = false
-
   async ready() {
     if (this._isReady) return
     this._isReady = true
     if (this.options.owners === 'auto') {
-      const owners = await this.adapter.fetchOwners()
+      const owners = await this.fetchOwners()
       this.owners.push(...owners)
     }
   }
 
-  constructor({
-    adapter,
-    ...options
-  }: Partial<CommandClientOptionsParam> & { adapter: HandlerAdapter<any> }) {
-    this.adapter = adapter
-    this.options = _.merge<
-      Partial<CommandClientOptionsParam>,
-      CommandClientOptions
-    >(options, {
+  constructor({ client, ...options }: Partial<CommandClientOptionsParam> & { client: Client }) {
+    this.client = client
+    this.options = _.merge<Partial<CommandClientOptionsParam>, CommandClientOptions>(options, {
       command: {
         prefix: '!',
       },
       owners: 'auto',
     })
-    adapter.init(this)
+    this.client.once('ready', () => this.ready())
+    this.registry.registerModule(new CommandHandler(this.registry))
+    this.registry.registerModule(new BuiltinCommandConverters(this))
   }
 }

package/src/structures/Module.ts

@@ -1,4 +1,25 @@
+import { KArgumentConverters, KCommands, KListeners, KModulePath } from '../constants'
+import type { Command } from '../command'
+import { Listener } from '../listener'
+import { ArgumentConverter } from '../command'
+
 export abstract class Module {
+  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 path(): string | undefined {
+    return Reflect.getMetadata(KModulePath, this)
+  }
+
   load() {}
   unload() {}
   beforeReload() {}