@pikokr/command.ts 5.0.0-dev.daaf714 → 5.0.1-dev.6c3e252

package/src/core/hooks/moduleHook.ts

@@ -1,7 +1,15 @@
+/*
+* 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 | symbol, Function[]>
+type ModuleHookStore = Collection<string, Function[]>
 
 export const getModuleHookStore = (target: object) => {
   let result: ModuleHookStore | null = Reflect.getMetadata(ModuleHookStoreSymbol, target)
@@ -19,11 +27,11 @@ export const moduleHook = (name: string): MethodDecorator => {
   return (target, key) => {
     const store = getModuleHookStore(target)
 
-    let v = store.get(key)
+    let v = store.get(name)
 
     if (!v) {
       v = []
-      store.set(key, v)
+      store.set(name, v)
     }
 
     v.push(Reflect.get(target, key))

package/src/core/index.ts

@@ -1,3 +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 './structures'
 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)

package/src/core/structures/CommandClient.ts

@@ -0,0 +1,78 @@
+/*
+* File: CommandClient.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import chalk from 'chalk'
+import { Client, Snowflake, Team, User } from 'discord.js'
+import EventEmitter from 'events'
+import { Logger } from 'tslog'
+import { ApplicationCommandExtension, ApplicationCommandExtensionConfig } from '../../applicationCommand/ApplicationCommandExtension'
+import { TextCommandConfig } from '../../textCommand'
+import { TextCommandExtension } from '../../textCommand/TextCommandExtension'
+import { CommandClientSymbol } from '../symbols'
+import { Registry } from './Registry'
+export class CommandClient extends EventEmitter {
+  ctsLogger: Logger
+  registry: Registry
+
+  owners: Set<Snowflake> = new Set()
+
+  constructor(public discord: Client, public logger: Logger = new Logger({ dateTimeTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone })) {
+    super()
+
+    this.ctsLogger = logger.getChildLogger({ prefix: [chalk.blue('[command.ts]')], displayFilePath: 'hidden', displayFunctionName: false })
+
+    this.registry = new Registry(this.ctsLogger, this)
+
+    this.registry.registerEventEmitter('cts', this)
+    this.registry.registerEventEmitter('discord', this.discord)
+  }
+
+  async fetchOwners() {
+    if (!this.discord.application) throw new Error('The client is not logged in.')
+
+    this.ctsLogger.info('Fetching owners...')
+
+    await this.discord.application.fetch()
+
+    const owner = this.discord.application.owner
+
+    if (!owner) throw new Error('Cannot find application owner')
+
+    const owners: string[] = []
+
+    if (owner instanceof User) {
+      this.owners.add(owner.id)
+      owners.push(owner.tag)
+    } else if (owner instanceof Team) {
+      for (const [id, member] of owner.members) {
+        this.owners.add(id)
+        owners.push(member.user.tag)
+      }
+    }
+
+    this.ctsLogger.info(`Fetched ${chalk.green(owners.length)} owners(${owners.map((x) => chalk.blue(x)).join(', ')})`)
+  }
+
+  async enableApplicationCommandsExtension(config: ApplicationCommandExtensionConfig) {
+    await this.registry.registerModule(new ApplicationCommandExtension(config))
+    this.ctsLogger.info('Application command extension enabled.')
+  }
+
+  async enableTextCommandsExtension(config: TextCommandConfig) {
+    await this.registry.registerModule(new TextCommandExtension(config))
+    this.ctsLogger.info('Text command extension enabled.')
+  }
+
+  getApplicationCommandsExtension() {
+    return this.registry.extensions.find((x) => x.constructor === ApplicationCommandExtension) as ApplicationCommandExtension | undefined
+  }
+
+  static getFromModule(ext: object): CommandClient {
+    return Reflect.getMetadata(CommandClientSymbol, ext)
+  }
+}

package/src/core/structures/Registry.ts

@@ -1,30 +1,176 @@
-import _ from 'lodash'
+/*
+ * File: Registry.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 EventEmitter from 'events'
+import _, { result } from 'lodash'
+import { Logger } from 'tslog'
 import { getComponentStore } from '../components'
+import type { BaseComponent } from '../components'
 import { getModuleHookStore } from '../hooks'
+import { ListenerComponent } from '../listener'
+import { CommandClientSymbol, FilePathSymbol } from '../symbols'
+import { CommandClient } from './CommandClient'
+import walkSync from 'walk-sync'
+import path from 'path'
 
 export class Registry {
   extensions: object[] = []
 
-  getComponentsWithType<T>(type: T): T[] {
-    const result: T[] = []
+  emitters: Collection<string, EventEmitter> = new Collection()
+
+  logger: Logger
+
+  constructor(logger: Logger, public client: CommandClient) {
+    this.logger = logger.getChildLogger({
+      prefix: [chalk.green('[Registry]')],
+    })
+  }
+
+  getComponentsWithTypeGlobal<T extends typeof BaseComponent<Config>, Config>(type: T): InstanceType<T>[] {
+    const result: InstanceType<T>[] = []
 
     for (const ext of this.extensions) {
-      const componentStore = getComponentStore(ext)
+      result.push(...this.getComponentsWithType(ext, type))
+    }
+
+    return result
+  }
+
+  getComponentsWithType<T extends typeof BaseComponent<Config>, Config>(ext: object, type: T): InstanceType<T>[] {
+    const componentStore = getComponentStore(ext)
+
+    return Array.from(componentStore.filter((x) => (x.constructor as unknown) === type).values() as Iterable<InstanceType<T>>)
+  }
+
+  registerEventListeners(ext: object) {
+    const listeners = this.getComponentsWithType(ext, ListenerComponent)
+
+    for (const listener of listeners) {
+      const emitter = this.emitters.get(listener.options.emitter)
 
-      result.push(...Array.from(componentStore.filter((x) => (x.constructor as unknown) === type).values() as Iterable<T>))
+      if (emitter) {
+        const bound = listener.method.bind(ext)
+
+        Reflect.defineMetadata('bound', bound, listener)
+
+        emitter.addListener(listener.options.event, bound)
+      }
+    }
+  }
+
+  unregisterEventListeners(ext: object) {
+    const listeners = this.getComponentsWithType(ext, ListenerComponent)
+
+    for (const listener of listeners) {
+      const emitter = this.emitters.get(listener.options.emitter)
+      const bound = Reflect.getMetadata('bound', listener)
+
+      if (emitter && bound) {
+        emitter.removeListener(listener.options.event, bound)
+      }
+    }
+  }
+
+  async loadAllModulesInDirectory(dir: string): Promise<object[]> {
+    const results: object[] = []
+
+    const files = walkSync(dir).filter((x) => x.endsWith('.ts') || x.endsWith('.js'))
+
+    for (const file of files) {
+      try {
+        const p = path.join(dir, file)
+        const mod = require(p)
+
+        if (typeof mod.setup !== 'function') continue
+
+        const modules = await mod.setup()
+
+        results.push(...(await this.registerModules(modules, p)))
+      } catch (e) {
+        this.logger.error(`Failed to load ${file}`)
+      }
+    }
+
+    return results
+  }
+
+  private async registerModules(modules: object | object[], p: string) {
+    const results: object[] = []
+    if (modules instanceof Array) {
+      for (const module of modules) {
+        await this.registerModule(module)
+        Reflect.defineMetadata(FilePathSymbol, p, module)
+        results.push(module)
+      }
+    } else {
+      await this.registerModule(modules)
+      Reflect.defineMetadata(FilePathSymbol, p, modules)
+      results.push(modules)
+    }
+
+    return results
+  }
+
+  async reloadModules() {
+    const result: { file: string; result: boolean; error?: Error }[] = []
+    const paths = new Set<string>()
+    for (const module of this.extensions) {
+      const file = Reflect.getMetadata(FilePathSymbol, module)
+      if (!file) continue
+
+      paths.add(file)
+
+      await this.unregisterModule(module)
+      delete require.cache[require.resolve(file)]
+    }
+
+    for (const path of paths) {
+      try {
+        const mod = require(path)
+
+        if (typeof mod.setup !== 'function') continue
+
+        const modules = await mod.setup()
+
+        await this.registerModules(modules, path)
+
+        result.push({
+          file: path,
+          result: true,
+        })
+      } catch (e) {
+        result.push({
+          file: path,
+          result: false,
+          error: e as Error,
+        })
+      }
     }
 
     return result
   }
 
   async registerModule(ext: object) {
+    Reflect.defineMetadata(CommandClientSymbol, this.client, ext)
+
+    this.registerEventListeners(ext)
     await this.runModuleHook(ext, 'load')
     this.extensions.push(ext)
+    this.logger.info(`Module registered: ${chalk.green(ext.constructor.name)}`)
   }
 
   async unregisterModule(ext: object) {
+    this.unregisterEventListeners(ext)
     await this.runModuleHook(ext, 'unload')
     _.remove(this.extensions, (x) => x === ext)
+    this.logger.info(`Module unregistered: ${chalk.green(ext.constructor.name)}`)
   }
 
   runModuleHook(ext: object, hookName: string, ...args: unknown[]) {
@@ -34,8 +180,12 @@ export class Registry {
 
     if (functions) {
       for (const fn of functions) {
-        fn.apply(ext, args)
+        fn.call(ext, ...args)
       }
     }
   }
+
+  registerEventEmitter(name: string, emitter: EventEmitter) {
+    this.emitters.set(name, emitter)
+  }
 }

package/src/core/structures/index.ts

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

package/src/core/symbols.ts

@@ -1,3 +1,14 @@
-export const ComponentStoreSymbol = Symbol()
-export const ComponentArgStoreSymbol = Symbol()
-export const ModuleHookStoreSymbol = Symbol()
+/*
+ * File: symbols.ts
+ *
+ * Copyright (c) 2022-2022 pikokr
+ *
+ * Licensed under MIT License. Please see more defails in LICENSE file.
+ */
+
+export const ComponentStoreSymbol = Symbol()
+export const ComponentArgStoreSymbol = Symbol()
+export const ModuleHookStoreSymbol = Symbol()
+export const CommandClientSymbol = Symbol()
+export const ComponentHookSymbol = Symbol()
+export const FilePathSymbol = Symbol()

package/src/core/utils/checks.ts

@@ -0,0 +1,27 @@
+/*
+* File: checks.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import { BaseInteraction, Interaction, Message } from 'discord.js'
+import { createComponentHook } from '../hooks'
+import { ComponentHookFn } from '../hooks/componentHook'
+import { CommandClient } from '../structures'
+import { OwnerOnlyError } from './errors'
+
+export const createCheckDecorator = (fn: ComponentHookFn) => createComponentHook('beforeCall', fn)
+
+export const ownerOnly = createCheckDecorator(async (client: CommandClient, i: Interaction | Message) => {
+  let isOwner = false
+
+  if (i instanceof BaseInteraction) {
+    isOwner = client.owners.has(i.user.id)
+  } else if (i instanceof Message) {
+    isOwner = client.owners.has(i.author.id)
+  }
+
+  if (!isOwner) throw new OwnerOnlyError()
+})

package/src/core/utils/errors.ts

@@ -0,0 +1,9 @@
+/*
+* File: errors.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+export class OwnerOnlyError {}

package/src/core/utils/index.ts

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

package/src/index.ts

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

package/src/textCommand/TextCommand.ts

@@ -0,0 +1,20 @@
+/*
+* File: TextCommand.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import { createComponentDecorator } from '../core/components/decoratorCreator'
+import { BaseComponent } from '../core/components/BaseComponent'
+
+type TextCommandOptions = {
+  name: string
+  aliases?: string
+  description?: string
+}
+
+export class TextCommandComponent extends BaseComponent<TextCommandOptions> {}
+
+export const command = createComponentDecorator(TextCommandComponent)

package/src/textCommand/TextCommandExtension.ts

@@ -0,0 +1,128 @@
+/*
+* File: TextCommandExtension.ts
+* 
+* Copyright (c) 2022-2022 pikokr
+* 
+* Licensed under MIT License. Please see more defails in LICENSE file.
+*/
+
+import { listener } from '../core/listener'
+import { Message } from 'discord.js'
+import { CTSExtension } from '../core/extensions/CTSExtension'
+import { TextCommandComponent } from './TextCommand'
+import { TextCommandRestOption } from './parameters'
+import { argConverter } from '../core'
+
+export type TextCommandConfig = {
+  prefix: string | string[] | ((msg: Message) => Promise<string | string[]> | string | string[])
+}
+
+export class TextCommandExtension extends CTSExtension {
+  constructor(private config: TextCommandConfig) {
+    super()
+  }
+
+  private async processPrefix(msg: Message): Promise<number | null> {
+    const content = msg.content
+    let prefix = this.config.prefix
+
+    if (typeof prefix === 'function') {
+      prefix = await prefix(msg)
+    }
+
+    if (typeof prefix === 'string') {
+      if (content.startsWith(prefix)) return prefix.length
+      return null
+    }
+
+    if (prefix instanceof Array) {
+      const p = prefix.find((x) => content.startsWith(x))
+
+      if (p) return p.length
+      return null
+    }
+
+    return null
+  }
+
+  @listener({ event: 'messageCreate', emitter: 'discord' })
+  private async messageCreate(msg: Message) {
+    const startIndex = await this.processPrefix(msg)
+
+    if (!startIndex) return
+
+    const content = msg.content.slice(startIndex)
+
+    const commands: TextCommandComponent[] = []
+
+    const extensions = new Map<TextCommandComponent, object>()
+
+    for (const ext of this.commandClient.registry.extensions) {
+      for (const cmd of this.commandClient.registry.getComponentsWithType(ext, TextCommandComponent)) {
+        commands.push(cmd)
+        extensions.set(cmd, ext)
+      }
+    }
+
+    let commandNameLength = 0
+
+    const command = commands.find((x) => {
+      const names = [x.options.name]
+
+      if (x.options.aliases) {
+        names.push(...x.options.aliases)
+      }
+
+      for (const name of names) {
+        if (content.startsWith(name)) {
+          if (content.length === name.length) {
+            commandNameLength = name.length
+            return true
+          }
+          commandNameLength = name.length
+          return content.startsWith(name + ' ')
+        }
+      }
+
+      return false
+    })
+
+    if (!command) return
+
+    const ext = extensions.get(command)
+
+    if (!ext) return
+
+    const args: unknown[] = []
+
+    let argStrings = content.slice(commandNameLength + 1).split(/ /g)
+
+    await this.convertArguments(TextCommandComponent, args, command.argTypes, async (arg, i, converter) => {
+      if (converter.options.parameterless) return [msg]
+
+      if (arg.decorators.find((x) => x.constructor === TextCommandRestOption)) {
+        const text = argStrings.join(' ')
+        argStrings = []
+        return [text, msg]
+      }
+      return [argStrings.shift(), msg]
+    })
+
+    await command.execute(ext, args, [msg])
+  }
+
+  @argConverter({ component: TextCommandComponent, type: Message, parameterless: true })
+  async mesage(msg: Message) {
+    return msg
+  }
+
+  @argConverter({ component: TextCommandComponent, type: String })
+  async str(value: string) {
+    return value
+  }
+
+  @argConverter({ component: TextCommandComponent, type: Number })
+  async num(value: string) {
+    return Number(value)
+  }
+}

package/src/textCommand/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 './TextCommand'
+export type { TextCommandConfig } from './TextCommandExtension'
+export * from './parameters'

package/src/textCommand/parameters.ts

@@ -0,0 +1,14 @@
+/*
+ * File: parameters.ts
+ *
+ * Copyright (c) 2022-2022 pikokr
+ *
+ * Licensed under MIT License. Please see more defails in LICENSE file.
+ */
+
+import { ComponentArgumentDecorator } from '../core'
+import { createArgumentDecorator } from '../core'
+
+export class TextCommandRestOption extends ComponentArgumentDecorator<void> {}
+
+export const rest = createArgumentDecorator(TextCommandRestOption)