@pikokr/command.ts 5.0.0-dev.84d717c → 5.0.0-dev.9362fb5

package/src/core/structures/CommandClient.ts

@@ -0,0 +1,71 @@
+/*
+* 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 { 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.')
+  }
+
+  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,19 +1,95 @@
+/*
+* 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 _ 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 } from '../symbols'
+import { CommandClient } from './CommandClient'
 
 export class Registry {
   extensions: object[] = []
 
-  async withGroup(name: string, code: () => void | Promise<void>) {}
+  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) {
+      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)
+
+      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 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[]) {
@@ -23,8 +99,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,13 @@
-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()

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

@@ -8,3 +8,4 @@
 
 export * from './core'
 export * from './applicationCommand'
+export * from './textCommand'

package/src/textCommand/TextCommand.ts

@@ -0,0 +1,11 @@
+import { createComponentDecorator } from '../core/components/decoratorCreator'
+import { BaseComponent } from '../core/components/BaseComponent'
+
+type TextCommandOptions = {
+  name: string
+  description?: string
+}
+
+export class TextCommandComponent extends BaseComponent<TextCommandOptions> {}
+
+export const command = createComponentDecorator(TextCommandComponent)

package/src/textCommand/index.ts

@@ -0,0 +1 @@
+export * from './TextCommand'

package/test/index.ts

@@ -1,22 +1,30 @@
-import { ApplicationCommandOptionType } from 'discord.js'
-import { applicationCommand, getComponentStore, moduleHook, option, Registry } from '../src'
+/*
+ * File: index.ts
+ *
+ * Copyright (c) 2022-2022 pikokr
+ *
+ * Licensed under MIT License. Please see more defails in LICENSE file.
+ */
 
-class Test {
+import { ApplicationCommandOptionType, ApplicationCommandType, ChatInputCommandInteraction, Client } from 'discord.js'
+import { applicationCommand, CommandClient, moduleHook, option, ownerOnly, listener, Extension } from '../dist'
+import 'dotenv/config'
+import { Logger } from 'tslog'
+import chalk from 'chalk'
+
+class Test extends Extension {
   @applicationCommand({
+    type: ApplicationCommandType.ChatInput,
     name: 'test',
     description: 'wow this is test',
   })
-  async testCommand(
-    @option({
-      name: 'hello',
-      description: '와아',
-      type: ApplicationCommandOptionType.String,
-    })
-    hello: string,
-    world: string,
-  ) {}
+  async testCommand(i: ChatInputCommandInteraction) {
+    i.reply('Wow')
+  }
 
+  @ownerOnly
   @applicationCommand({
+    type: ApplicationCommandType.ChatInput,
     name: 'test2',
     description: 'wow this is test wow',
   })
@@ -25,29 +33,51 @@ class Test {
       name: 'sans',
       description: '와',
       type: ApplicationCommandOptionType.String,
+      required: true,
     })
     wa: string,
-  ) {}
+    i: ChatInputCommandInteraction,
+  ) {
+    i.reply(wa)
+  }
 
   @moduleHook('load')
   load() {
-    console.log('load')
+    this.logger.info('Load')
   }
 
   @moduleHook('unload')
   unload() {
-    console.log('unload')
+    this.logger.info('Unload')
+  }
+
+  @listener({ event: 'ready' })
+  async testEvent() {
+    this.logger.info(`Login: ${chalk.green(client.user!.tag)}`)
+    await this.commandClient.fetchOwners()
   }
 }
 
 const ext = new Test()
 
-const registry = new Registry()
+const client = new Client({ intents: [] })
+
+const logger = new Logger({ dateTimeTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone })
+
+const cc = new CommandClient(client, logger)
+
+const registry = cc.registry
 
 const run = async () => {
+  await cc.enableApplicationCommandsExtension({
+    guilds: ['832938554438844438'],
+  })
+
   await registry.registerModule(ext)
 
-  await registry.unregisterModule(ext)
+  await client.login(process.env.TOKEN)
+
+  await cc.getApplicationCommandsExtension()!.sync()
 }
 
 run()

package/tsconfig.json

@@ -15,11 +15,10 @@
     "declaration": true,
     /* Generates corresponding '.d.ts' file. */
     // "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
-     "sourceMap": true,                           /* Generates corresponding '.map' file. */
+    "sourceMap": true /* Generates corresponding '.map' file. */,
     // "outFile": "./",                             /* Concatenate and emit output to single file. */
     "outDir": "./dist",
     /* Redirect output structure to the directory. */
-    "rootDir": "./src",
     /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
     // "composite": true,                           /* Enable project compilation */
     // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
@@ -31,6 +30,7 @@
 
     /* Strict Type-Checking Options */
     "strict": true,
+
     /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                       /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,                    /* Enable strict null checks. */

package/tsconfig.prod.json

@@ -1,4 +1,8 @@
 {
   "extends": "./tsconfig.json",
-  "exclude": ["node_modules", "scripts", "test", "tsup.config.ts"]
-}
+  "exclude": ["node_modules", "scripts", "test", "tsup.config.ts"],
+  "include": ["src"],
+  "compilerOptions": {
+    "rootDir": "./src",
+  }
+}

package/tsup.config.ts

@@ -15,4 +15,5 @@ export default defineConfig({
   clean: true,
   dts: true,
   minify: true,
+  tsconfig: 'tsconfig.prod.json',
 })