@pikokr/command.ts 3.0.0-dev.a94f324 → 3.0.0-dev.ca01eb5

package/src/command/Command.ts

@@ -1,20 +1,31 @@
 import { Module } from '../structures'
-import { Message } from 'discord.js'
+import { CommandInteraction, 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 type SlashCheckFunction = (i: CommandInteraction) => boolean | Promise<boolean>
+
 export class Command {
   execute(module: Module, args: any[]) {
     return this.run.apply(module, args)
   }
 
+  get checks(): CheckFunction[] {
+    return Reflect.getMetadata(KCommandChecks, this.module, this.key) || []
+  }
+
   constructor(
     private run: Function,
     public argTypes: Argument[],
     public name: string,
     public aliases: string[] | ((msg: Message) => string[]),
+    public module: Module,
+    public key: symbol | string,
   ) {}
 }

package/src/command/cooldown/adapter.ts

@@ -0,0 +1,18 @@
+import { Collection, Guild, GuildChannel, GuildMember, Message, Role, TextChannel, ThreadChannel, User } from 'discord.js'
+
+export interface CoolDownAdapter {
+  get(id: string): Promise<number | undefined>
+  set(id: string, value: number): Promise<void>
+}
+
+export class DefaultCoolDownAdapter implements CoolDownAdapter {
+  map = new Collection<string, number>()
+  async get(id: string): Promise<number | undefined> {
+    return this.map.get(id)
+  }
+
+  async set(id: string, value: number) {
+    this.map.set(id, value)
+    return
+  }
+}

package/src/command/cooldown/decorator.ts

@@ -0,0 +1,62 @@
+import { createCheckDecorator } from '../utils'
+import { CoolDownType } from './type'
+import { DMChannel, GuildMember, TextChannel } from 'discord.js'
+import { CoolDownError } from './error'
+
+export const coolDown = (type: CoolDownType, seconds: number) =>
+  createCheckDecorator(
+    async (msg) => {
+      const a = msg.data.cts.coolDownAdapter
+      const getKey = (): string => {
+        switch (type) {
+          case CoolDownType.USER:
+            return msg.author.id
+          case CoolDownType.GUILD:
+            return (msg.guild || msg.author).id
+          case CoolDownType.CHANNEL:
+            return msg.channel.id
+          case CoolDownType.MEMBER:
+            return `${msg.guild?.id}.${msg.author.id}`
+          case CoolDownType.ROLE:
+            return (msg.channel instanceof DMChannel ? msg.channel : msg.member!.roles.highest).id
+          case CoolDownType.CATEGORY:
+            return ((msg.channel as TextChannel).parent || msg.channel).id
+        }
+      }
+      const key = getKey()
+      const data = await a.get(key)
+      const now = Date.now()
+      if (!data || !(now - data < seconds * 1000)) {
+        await a.set(key, now)
+        return true
+      }
+      throw new CoolDownError(new Date(data + seconds * 1000))
+    },
+    async (i) => {
+      const a = i.data.cts.coolDownAdapter
+      const getKey = (): string => {
+        switch (type) {
+          case CoolDownType.USER:
+            return i.user.id
+          case CoolDownType.GUILD:
+            return (i.guild || i.user).id
+          case CoolDownType.CHANNEL:
+            return i.channel!.id
+          case CoolDownType.MEMBER:
+            return `${i.guild?.id}.${i.user.id}`
+          case CoolDownType.ROLE:
+            return (i.channel instanceof DMChannel ? i.channel : (i.member as GuildMember)!.roles.highest).id
+          case CoolDownType.CATEGORY:
+            return ((i.channel as TextChannel).parent || i.channel!).id
+        }
+      }
+      const key = getKey()
+      const data = await a.get(key)
+      const now = Date.now()
+      if (!data || !(now - data < seconds * 1000)) {
+        await a.set(key, now)
+        return true
+      }
+      throw new CoolDownError(new Date(data + seconds * 1000))
+    },
+  )

package/src/command/cooldown/error.ts

@@ -0,0 +1,5 @@
+export class CoolDownError extends Error {
+  constructor(public endsAt: Date) {
+    super()
+  }
+}

package/src/command/cooldown/index.ts

@@ -0,0 +1,5 @@
+export * from './decorator'
+export * from './adapter'
+export * from './decorator'
+export * from './error'
+export * from './type'

package/src/command/cooldown/type.ts

@@ -0,0 +1,8 @@
+export enum CoolDownType {
+  USER,
+  CHANNEL,
+  GUILD,
+  ROLE,
+  CATEGORY,
+  MEMBER,
+}

package/src/command/decorator.ts

@@ -1,11 +1,15 @@
-import { KArgumentConverters, KCommands, KOptionals } from '../constants'
+import { KArgumentConverters, KCommands, KOptionals, KRest, KSlashArgumentConverters } from '../constants'
 import { Command } from './Command'
 import { checkTarget } from '../utils'
-import { ArgumentConverter } from './ArgumentConverter'
+import { ArgumentConverter, SlashArgumentConverter } from './ArgumentConverter'
+import { Module } from '../structures'
+import { createCheckDecorator } from './utils'
+import { GuildMember, Message, PermissionResolvable, Permissions, TextChannel } from 'discord.js'
+import { ClientPermissionRequired, UserPermissionRequired } from '../error'
 
 type CommandOptions = {
   name: string
-  aliases: string[]
+  aliases: string[] | ((msg: Message) => string[])
 }
 
 export const command = (options: Partial<CommandOptions> = {}) => {
@@ -18,23 +22,23 @@ export const command = (options: Partial<CommandOptions> = {}) => {
 
     let properties: Command[] = Reflect.getMetadata(KCommands, target)
 
-    const params: any[] = 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 optionals: number[] =
-      Reflect.getMetadata(KOptionals, target, propertyKey) || []
+    const rest = Reflect.getMetadata(KRest, target, propertyKey) || -1
 
     const command = new Command(
       Reflect.get(target, propertyKey),
       params.map((x, i) => ({
         type: x,
-        optional: optionals.includes(i),
+        optional: optionals === -1 ? false : optionals <= i,
+        rest: rest === -1 ? false : rest === i,
       })),
       options.name || propertyKey,
       options.aliases || [],
+      target as Module,
+      propertyKey,
     )
 
     if (properties) {
@@ -54,16 +58,9 @@ export const argumentConverter = (type: object, requireParameter = true) => {
   ) => {
     checkTarget(target)
 
-    let properties: ArgumentConverter[] = Reflect.getMetadata(
-      KArgumentConverters,
-      target,
-    )
+    let properties: ArgumentConverter[] = Reflect.getMetadata(KArgumentConverters, target)
 
-    const converter = new ArgumentConverter(
-      type,
-      Reflect.get(target, propertyKey),
-      !requireParameter,
-    )
+    const converter = new ArgumentConverter(type, Reflect.get(target, propertyKey), !requireParameter)
 
     if (properties) {
       properties.push(converter)
@@ -74,23 +71,92 @@ export const argumentConverter = (type: object, requireParameter = true) => {
   }
 }
 
-export const optional: ParameterDecorator = (
-  target,
-  propertyKey,
-  parameterIndex,
-) => {
-  checkTarget(target)
+export const slashArgumentConverter = (type: object) => {
+  return (
+    target: Object,
+    propertyKey: string,
+    // descriptor: TypedPropertyDescriptor<any>,
+  ) => {
+    checkTarget(target)
 
-  let properties: number[] = Reflect.getMetadata(
-    KOptionals,
-    target,
-    propertyKey,
-  )
+    let properties: SlashArgumentConverter[] = Reflect.getMetadata(KSlashArgumentConverters, target)
 
-  if (properties) {
-    properties.push(parameterIndex)
-  } else {
-    properties = [parameterIndex]
-    Reflect.defineMetadata(KOptionals, properties, target, propertyKey)
+    const converter = new SlashArgumentConverter(type, Reflect.get(target, propertyKey))
+
+    if (properties) {
+      properties.push(converter)
+    } else {
+      properties = [converter]
+      Reflect.defineMetadata(KSlashArgumentConverters, 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),
+  (i) => i.data.cts.owners.includes(i.user.id),
+)
+
+export const guildOnly = createCheckDecorator(
+  (msg) => !!msg.guild,
+  (i) => !!i.guildId,
+)
+
+export const dmOnly = createCheckDecorator(
+  (msg) => !msg.guild,
+  (i) => !i.guildId,
+)
+
+export const requireUserPermissions = (permission: PermissionResolvable) =>
+  createCheckDecorator(
+    (msg) => {
+      if (!msg.guild || !msg.member) throw new Error('This command must be used in guild.')
+      if (msg.member.permissionsIn(msg.channel as TextChannel).has(permission)) {
+        return true
+      }
+      throw new UserPermissionRequired(msg.member, new Permissions(permission))
+    },
+    (i) => {
+      if (!i.guild || !i.member) throw new Error('This command must be used in serer.')
+      if (!(i.member instanceof GuildMember) || i.member.permissionsIn(i.channel as TextChannel).has(permission)) {
+        return true
+      }
+      throw new UserPermissionRequired(i.member, new Permissions(permission))
+    },
+  )
+
+export const requireClientPermissions = (permission: PermissionResolvable) =>
+  createCheckDecorator(
+    (msg) => {
+      if (!msg.guild) throw new Error('This command must be used in guild.')
+      if (msg.guild.me!.permissionsIn(msg.channel as TextChannel).has(permission)) {
+        return true
+      }
+      throw new ClientPermissionRequired(new Permissions(permission))
+    },
+    (i) => {
+      if (!i.guild) throw new Error('This command must be used in guild.')
+      if (i.guild.me!.permissionsIn(i.channel as TextChannel).has(permission)) {
+        return true
+      }
+      throw new ClientPermissionRequired(new Permissions(permission))
+    },
+  )

package/src/command/index.ts

@@ -1,3 +1,5 @@
 export * from './Command'
 export * from './decorator'
 export * from './ArgumentConverter'
+export * from './utils'
+export * from './cooldown'

package/src/command/utils.ts

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

package/src/constants.ts

@@ -1,5 +1,9 @@
 export const KCommands = Symbol('Command.TS Commands')
 
+export const KSlashCommands = Symbol('Command.TS Slash Commands')
+
+export const KSlashCommandOptions = Symbol('Command.TS Slash Command Options')
+
 export const KListeners = Symbol('Command.TS Listeners')
 
 export const KModulePath = Symbol('Command.TS Module Path')
@@ -10,4 +14,12 @@ 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 KSlashArgumentConverters = Symbol('Command.TS Slash Argument Converter')
+
+export const KCommandChecks = Symbol('Command.TS Command Checks')
+
+export const KSlashCommandChecks = Symbol('Command.TS Slash Command Checks')

package/src/error/ArgumentConverterNotFound.ts

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

package/src/error/ArgumentNotProvided.ts

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

package/src/error/CommandCheckFailed.ts

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

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

@@ -2,3 +2,5 @@ export * from './InvalidTargetError'
 export * from './ModuleError'
 export * from './ArgumentNotProvided'
 export * from './ArgumentConverterNotFound'
+export * from './CommandCheckFailed'
+export * from './PermissionRequired'

package/src/index.ts

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

package/src/slashCommand/SlashCommand.ts

@@ -0,0 +1,29 @@
+import { SlashCommandBuilder } from '@discordjs/builders'
+import { Module } from '../structures'
+import { Snowflake } from 'discord.js'
+import { KSlashCommandChecks } from '../constants'
+import { SlashCheckFunction } from '../command'
+
+export type SlashArgument = {
+  type: any
+  name?: string
+}
+
+export class SlashCommand {
+  get checks(): SlashCheckFunction[] {
+    return Reflect.getMetadata(KSlashCommandChecks, this.module, this.key) || []
+  }
+
+  execute(module: Module, args: any[]) {
+    return this.run.apply(module, args)
+  }
+
+  constructor(
+    public commandBuilder: SlashCommandBuilder | Omit<SlashCommandBuilder, 'addSubcommand' | 'addSubcommandGroup'>,
+    private run: Function,
+    public module: Module,
+    public params: SlashArgument[],
+    public guild: Snowflake | Snowflake[] | undefined,
+    private key: string | symbol,
+  ) {}
+}

package/src/slashCommand/decorator.ts

@@ -0,0 +1,58 @@
+import { Collection, Snowflake } from 'discord.js'
+import { checkTarget } from '../utils'
+import { KSlashCommandOptions, KSlashCommands } from '../constants'
+import { Module } from '../structures'
+import { SlashCommand } from './SlashCommand'
+import { SlashCommandBuilder } from '@discordjs/builders'
+
+type SlashOptions = {
+  guild: Snowflake | Snowflake[]
+}
+
+export const slashCommand = (opt: Partial<SlashOptions> & { command: SlashCommandBuilder | Omit<SlashCommandBuilder, 'addSubcommand' | 'addSubcommandGroup'> }) => {
+  return (
+    target: Object,
+    propertyKey: string,
+    // descriptor: TypedPropertyDescriptor<any>,
+  ) => {
+    checkTarget(target)
+
+    let properties: SlashCommand[] = Reflect.getMetadata(KSlashCommands, target)
+
+    const params: any[] = Reflect.getMetadata('design:paramtypes', target, propertyKey)
+
+    const options: Collection<number, string> = Reflect.getMetadata(KSlashCommandOptions, target, propertyKey) || new Collection<number, string>()
+
+    const command = new SlashCommand(
+      opt.command,
+      Reflect.get(target, propertyKey),
+      target as Module,
+      params.map((x, i) => ({
+        type: x,
+        name: options.get(i),
+      })),
+      opt.guild,
+      propertyKey,
+    )
+
+    if (properties) {
+      properties.push(command)
+    } else {
+      properties = [command]
+      Reflect.defineMetadata(KSlashCommands, properties, target)
+    }
+  }
+}
+
+export const option = (key: string): ParameterDecorator => (target, propertyKey, parameterIndex) => {
+  checkTarget(target)
+
+  let properties: Collection<number, string> = Reflect.getMetadata(KSlashCommandOptions, target, propertyKey)
+
+  if (!properties) {
+    properties = new Collection<number, string>()
+    Reflect.defineMetadata(KSlashCommandOptions, properties, target, propertyKey)
+  }
+
+  properties.set(parameterIndex, key)
+}

package/src/slashCommand/index.ts

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

package/src/structures/CommandClient.ts

@@ -1,23 +1,29 @@
 import _ from 'lodash'
 import { Registry } from './Registry'
-import { Client, Message, User } from 'discord.js'
-import { BuiltinCommandConverters, CommandHandler } from '../builtinModules'
+import { Client, Snowflake, User } from 'discord.js'
+import { BuiltinCommandConverters, BuiltinSlashCommandConverters, CommandHandler } from '../builtinModules'
+import { CoolDownAdapter, DefaultCoolDownAdapter } from '../command'
+import { REST } from '@discordjs/rest'
 
 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 SlashCommandOptions {
+  guild?: Snowflake | Snowflake[]
+  autoSync: boolean
 }
 
 export interface CommandClientOptions {
   command: CommandOptions
-  owners: 'auto' | string[]
+  owners: 'auto' | Snowflake[]
+  slashCommands: SlashCommandOptions
 }
 
 export interface CommandClientOptionsParam {
   command: Partial<CommandOptions>
   owners: 'auto' | string[]
+  slashCommands: Partial<SlashCommandOptions>
 }
 
 export class CommandClient {
@@ -25,10 +31,15 @@ export class CommandClient {
   owners: string[] = []
   registry = new Registry(this)
   client: Client
+  coolDownAdapter: CoolDownAdapter
+  rest = new REST({
+    version: '9',
+  })
 
   private _isReady = false
 
-  private fetchOwners(): string[] {
+  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]
@@ -37,29 +48,30 @@ export class CommandClient {
 
   async ready() {
     if (this._isReady) return
+    this.rest.setToken(this.client.token!)
     this._isReady = true
     if (this.options.owners === 'auto') {
-      const owners = this.fetchOwners()
+      const owners = await this.fetchOwners()
       this.owners.push(...owners)
     }
+    await this.registry.syncCommands()
   }
 
-  constructor({
-    client,
-    ...options
-  }: Partial<CommandClientOptionsParam> & { client: Client }) {
+  constructor({ client, coolDownAdapter, ...options }: Partial<CommandClientOptionsParam> & { client: Client; coolDownAdapter?: CoolDownAdapter }) {
     this.client = client
-    this.options = _.merge<
-      Partial<CommandClientOptionsParam>,
-      CommandClientOptions
-    >(options, {
+    this.coolDownAdapter = coolDownAdapter || new DefaultCoolDownAdapter()
+    this.options = _.merge<Partial<CommandClientOptionsParam>, CommandClientOptions>(options, {
       command: {
         prefix: '!',
       },
       owners: 'auto',
+      slashCommands: {
+        autoSync: true,
+      },
     })
-    this.client.once('ready', this.ready)
+    this.client.once('ready', () => this.ready())
     this.registry.registerModule(new CommandHandler(this.registry))
-    this.registry.registerModule(new BuiltinCommandConverters())
+    this.registry.registerModule(new BuiltinCommandConverters(this))
+    this.registry.registerModule(new BuiltinSlashCommandConverters(this))
   }
 }

package/src/structures/Module.ts

@@ -1,7 +1,8 @@
-import { KArgumentConverters, KCommands, KListeners } from '../constants'
+import { KArgumentConverters, KCommands, KListeners, KModulePath, KSlashArgumentConverters, KSlashCommands } from '../constants'
 import type { Command } from '../command'
 import { Listener } from '../listener'
-import { ArgumentConverter } from '../command'
+import { ArgumentConverter, SlashArgumentConverter } from '../command'
+import { SlashCommand } from '../slashCommand'
 
 export abstract class Module {
   get commands(): Command[] {
@@ -16,6 +17,18 @@ export abstract class Module {
     return Reflect.getMetadata(KArgumentConverters, this) || []
   }
 
+  get slashArgumentConverters(): SlashArgumentConverter[] {
+    return Reflect.getMetadata(KSlashArgumentConverters, this) || []
+  }
+
+  get slashCommands(): SlashCommand[] {
+    return Reflect.getMetadata(KSlashCommands, this) || []
+  }
+
+  get path(): string | undefined {
+    return Reflect.getMetadata(KModulePath, this)
+  }
+
   load() {}
   unload() {}
   beforeReload() {}