meocord 3.1.0 → 3.2.0

package/dist/esm/bin/app-template/src/controllers/reaction/sample.reaction.controller.ts.template

@@ -0,0 +1,29 @@
+import { MessageReaction } from 'discord.js'
+import { Controller, ReactionHandler } from 'meocord/decorator'
+import { Logger } from 'meocord/common'
+import { ReactionHandlerAction } from 'meocord/enum'
+import { type ReactionHandlerOptions } from 'meocord/interface'
+
+@Controller()
+export class SampleReactionController {
+  private readonly logger = new Logger(SampleReactionController.name)
+
+  @ReactionHandler('😋')
+  async handleReaction(reaction: MessageReaction, { user, action }: ReactionHandlerOptions) {
+    this.logger.log(`Reaction 😋 ${action === ReactionHandlerAction.ADD ? 'added' : 'removed'}.`)
+
+    if (!reaction.message) return
+
+    if (action === ReactionHandlerAction.ADD) {
+      await reaction.message.reply(`${user.username} reacted with 😋!`)
+    }
+  }
+
+  @ReactionHandler()
+  async handleAnyReaction(reaction: MessageReaction, { user, action }: ReactionHandlerOptions) {
+    this.logger.log('Reaction detected!')
+    if (reaction.message && action === ReactionHandlerAction.ADD) {
+      await reaction.message.reply(`${user.username} reacted with ${reaction.emoji.name}!`)
+    }
+  }
+}

package/dist/esm/bin/app-template/src/controllers/select-menu/sample.select-menu.controller.spec.ts.template

@@ -0,0 +1,17 @@
+import { MeoCordTestingModule } from 'meocord/testing'
+import { SampleSelectMenuController } from '@src/controllers/select-menu/sample.select-menu.controller.js'
+
+describe('SampleSelectMenuController', () => {
+  let controller: SampleSelectMenuController
+
+  beforeEach(() => {
+    const module = MeoCordTestingModule.create({
+      controllers: [SampleSelectMenuController],
+    }).compile()
+    controller = module.get(SampleSelectMenuController)
+  })
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined()
+  })
+})

package/dist/esm/bin/app-template/src/controllers/select-menu/sample.select-menu.controller.ts.template

@@ -0,0 +1,11 @@
+import { StringSelectMenuInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@Controller()
+export class SampleSelectMenuController {
+  @Command('select-menu', CommandType.SELECT_MENU)
+  async handleSelectMenu(interaction: StringSelectMenuInteraction) {
+    await interaction.reply('Select menu used!')
+  }
+}

package/dist/esm/bin/app-template/src/controllers/slash/builders/sample.builder.ts.template

@@ -0,0 +1,10 @@
+import { SlashCommandBuilder } from 'discord.js'
+import { CommandBuilder } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@CommandBuilder(CommandType.SLASH)
+export class SampleCommandBuilder {
+  build(commandName: string) {
+    return new SlashCommandBuilder().setName(commandName).setDescription('This is a sample slash command')
+  }
+}

package/dist/esm/bin/app-template/src/controllers/slash/sample.slash.controller.spec.ts.template

@@ -0,0 +1,17 @@
+import { MeoCordTestingModule } from 'meocord/testing'
+import { SampleSlashController } from '@src/controllers/slash/sample.slash.controller.js'
+
+describe('SampleSlashController', () => {
+  let controller: SampleSlashController
+
+  beforeEach(() => {
+    const module = MeoCordTestingModule.create({
+      controllers: [SampleSlashController],
+    }).compile()
+    controller = module.get(SampleSlashController)
+  })
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined()
+  })
+})

package/dist/esm/bin/app-template/src/controllers/slash/sample.slash.controller.ts.template

@@ -0,0 +1,19 @@
+import { ChatInputCommandInteraction } from 'discord.js'
+import { Controller, Command, UseGuard } from 'meocord/decorator'
+import { SampleCommandBuilder } from '@src/controllers/slash/builders/sample.builder'
+import { RateLimitGuard } from '@src/guards/rate-limit.guard'
+
+@Controller()
+export class SampleSlashController {
+  @Command('sample-slash', SampleCommandBuilder)
+  @UseGuard(RateLimitGuard)
+  async handleSampleSlash(interaction: ChatInputCommandInteraction) {
+    await interaction.reply('This is sample reply of slash command.')
+  }
+
+  @Command('sample-slash-2', SampleCommandBuilder)
+  @UseGuard({ provide: RateLimitGuard, params: { limit: 2, windowInSeconds: 60 } })
+  async handleSampleSlashTwo(interaction: ChatInputCommandInteraction) {
+    await interaction.reply('This is sample reply of slash command.')
+  }
+}

package/dist/esm/bin/app-template/src/guards/rate-limit.guard.spec.ts.template

@@ -0,0 +1,13 @@
+import { RateLimitGuard } from '@src/guards/rate-limit.guard.js'
+
+describe('RateLimitGuard', () => {
+  let guard: RateLimitGuard
+
+  beforeEach(() => {
+    guard = new RateLimitGuard({ limit: 3, windowInSeconds: 60 })
+  })
+
+  it('should be defined', () => {
+    expect(guard).toBeDefined()
+  })
+})

package/dist/esm/bin/app-template/src/guards/rate-limit.guard.ts.template

@@ -0,0 +1,52 @@
+import { Guard } from 'meocord/decorator'
+import { type GuardInterface } from 'meocord/interface'
+import { BaseInteraction } from 'discord.js'
+import { Logger } from 'meocord/common'
+
+class RateLimiterGuardOptions {
+  limit?: number
+  windowInSeconds?: number
+}
+
+@Guard()
+export class RateLimitGuard implements GuardInterface {
+  // ==============================
+  // NOTE: Consider using Redis or another distributed store for rate limits in production
+  // ==============================
+  private logger = new Logger(RateLimitGuard.name)
+
+  private rateLimits = new Map<string, number[]>()
+  private readonly limit: number
+  private readonly windowInSeconds: number
+
+  constructor(options: RateLimiterGuardOptions = {}) {
+    this.limit = options.limit || 5
+    this.windowInSeconds = options.windowInSeconds || 60
+  }
+
+  async canActivate(interaction: BaseInteraction): Promise<boolean> {
+    const userId = interaction.user.id
+
+    let key: string
+    if (interaction.isChatInputCommand()) {
+      const commandId = interaction.commandName
+      const subCommand = interaction.options.getSubcommand(false) || ''
+      key = subCommand ? `${commandId}:${subCommand}:${userId}` : `${commandId}:${userId}`
+    } else if (interaction.isMessageComponent()) {
+      key = `${interaction.customId}:${userId}`
+    } else {
+      key = userId
+    }
+
+    const currentTime = Math.floor(Date.now() / 1000)
+    const timestamps = this.rateLimits.get(key) || []
+
+    const filteredTimestamps = timestamps.filter(time => currentTime - time < this.windowInSeconds)
+    filteredTimestamps.push(currentTime)
+    this.rateLimits.set(key, filteredTimestamps)
+
+    this.logger.debug(key, filteredTimestamps.length, this.limit, this.windowInSeconds)
+
+    return filteredTimestamps.length <= this.limit
+  }
+}

package/dist/esm/bin/app-template/src/main.ts.template

@@ -0,0 +1,14 @@
+import App from '@src/app'
+import { Logger } from 'meocord/common'
+import { MeoCordFactory } from 'meocord/core'
+
+const logger = new Logger()
+const app = MeoCordFactory.create(App)
+
+async function bootstrap() {
+  logger.log('Starting application')
+  await app.start()
+  logger.log('Application started')
+}
+
+bootstrap().catch(error => logger.error('Error during startup:', error))

package/dist/esm/bin/app-template/src/services/sample.service.spec.ts.template

@@ -0,0 +1,17 @@
+import { MeoCordTestingModule } from 'meocord/testing'
+import { SampleService } from '@src/services/sample.service.js'
+
+describe('SampleService', () => {
+  let service: SampleService
+
+  beforeEach(() => {
+    const module = MeoCordTestingModule.create({
+      providers: [{ provide: SampleService, useClass: SampleService }],
+    }).compile()
+    service = module.get(SampleService)
+  })
+
+  it('should be defined', () => {
+    expect(service).toBeDefined()
+  })
+})

package/dist/esm/bin/app-template/src/services/sample.service.ts.template

@@ -0,0 +1,9 @@
+import { Service } from 'meocord/decorator'
+
+@Service()
+export class SampleService {
+  async handleInteraction() {
+    // TODO: Implement service logic
+    return 'SampleService is working!'
+  }
+}

package/dist/esm/bin/app-template/tsconfig.eslint.json.template

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["meocord.eslint.ts", "meocord.config.ts", "vitest.config.ts", "eslint.config.ts"],
+  "exclude": ["node_modules"]
+}

package/dist/esm/bin/app-template/tsconfig.json.template

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "target": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "strictNullChecks": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": false,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "skipLibCheck": true,
+    "noImplicitAny": false,
+    "noEmit": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "paths": {
+      "@src/*": ["./src/*"]
+    },
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["meocord.config.ts", "dist", "vitest.config.ts", "node_modules", "src/**/*.spec.ts"]
+}

package/dist/esm/bin/app-template/tsconfig.test.json.template

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/dist/esm/bin/app-template/vitest.config.ts.template

@@ -0,0 +1,35 @@
+import { defineConfig } from 'vitest/config'
+import swc from 'unplugin-swc'
+import { fileURLToPath } from 'node:url'
+
+export default defineConfig({
+  // SWC rather than vite's esbuild: esbuild cannot emit decorator metadata, which the
+  // dependency injection behind @Controller and @Service reads at runtime.
+  plugins: [
+    swc.vite({
+      jsc: {
+        parser: { syntax: 'typescript', decorators: true },
+        transform: { legacyDecorator: true, decoratorMetadata: true },
+        target: 'es2022',
+      },
+      module: { type: 'es6' },
+    }),
+  ],
+  resolve: {
+    alias: { '@src': fileURLToPath(new URL('./src', import.meta.url)) },
+  },
+  test: {
+    globals: true,
+    setupFiles: ['reflect-metadata'],
+    clearMocks: true,
+    include: ['src/**/*.spec.ts'],
+    coverage: {
+      // istanbul rather than v8: v8 coverage needs Node's inspector API, which bun does
+      // not implement, and this template is expected to run under either runtime.
+      provider: 'istanbul',
+      all: false,
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/*.spec.ts'],
+    },
+  },
+})

package/dist/esm/bin/builder-template/controller/button.controller.template

@@ -10,7 +10,7 @@ export class {{className}}ButtonController {
     await interaction.reply('Button clicked!')
   }
 
-  @Command('button-with-{id}', CommandType.BUTTON)
+  @Command('button-with/{id}', CommandType.BUTTON)
   async handleButtonWithId(interaction: ButtonInteraction, { id }) {
     await interaction.reply(`Button with id: ${id} clicked!`)
   }

package/dist/esm/bin/helper/app-generator.helper.js

@@ -0,0 +1,78 @@
+import fs__default from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { populateTemplate } from '../../util/generator-cli.util.js';
+
+const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+/** Marks a packaged template file, and is dropped from the name that gets written. */ const TEMPLATE_SUFFIX = '.template';
+/**
+ * Stands in for a leading dot while the file is packaged.
+ *
+ * npm omits a `.gitignore` from a published tarball, and this repository's own tooling
+ * would treat a packaged `.ts` as one of its sources, so nothing here is stored under
+ * the name it is written as.
+ */ const DOT_PREFIX = '_';
+/**
+ * The prefix each package manager needs for the framework to run on its runtime.
+ *
+ * The separating space belongs to the value, because the template writes
+ * `{{runtimePrefix}}meocord` with nothing between them — a package manager that needs
+ * no prefix has to render as `meocord …` rather than ` meocord …`. Trimming an entry
+ * here would join it to the command that follows.
+ */ const RUNTIME_PREFIXES = {
+    // Without `--bun`, bun honours the CLI's `#!/usr/bin/env node` line and hands it to
+    // node, which an image built on bun alone does not have.
+    bun: 'bun --bun '
+};
+/**
+ * The script prefix for a package manager.
+ *
+ * @param packageManager - Package manager the application was created with.
+ */ function runtimePrefixFor(packageManager) {
+    return RUNTIME_PREFIXES[packageManager] ?? '';
+}
+/** The name a packaged template is written under. */ function outputName(templateName) {
+    const name = templateName.endsWith(TEMPLATE_SUFFIX) ? templateName.slice(0, -TEMPLATE_SUFFIX.length) : templateName;
+    return name.startsWith(DOT_PREFIX) ? `.${name.slice(DOT_PREFIX.length)}` : name;
+}
+/**
+ * Writes a new application from the template packaged with this framework.
+ *
+ * The template ships inside the package rather than being fetched, so the application a
+ * given release scaffolds is always one that release can run. A template resolved at
+ * generation time drifts from the CLI asking for it, in whichever direction happens to
+ * be newer.
+ */ class AppGeneratorHelper {
+    /**
+   * Renders every packaged template file into the target directory.
+   *
+   * @param targetDir - Directory to write the application into.
+   * @param variables - Values substituted into the template.
+   * @returns The written paths, relative to the target directory.
+   */ generateApp(targetDir, variables) {
+        return this.templateFiles(this.templateDir).map((templatePath)=>{
+            const relative = path.relative(this.templateDir, templatePath).split(path.sep).map((segment)=>outputName(segment)).join(path.sep);
+            const destination = path.join(targetDir, relative);
+            fs__default.mkdirSync(path.dirname(destination), {
+                recursive: true
+            });
+            fs__default.writeFileSync(destination, populateTemplate(templatePath, variables));
+            return relative;
+        });
+    }
+    templateFiles(dir) {
+        return fs__default.readdirSync(dir, {
+            withFileTypes: true
+        }).flatMap((entry)=>{
+            const full = path.join(dir, entry.name);
+            return entry.isDirectory() ? this.templateFiles(full) : [
+                full
+            ];
+        });
+    }
+    constructor(){
+        this.templateDir = path.resolve(__dirname$1, '..', 'app-template');
+    }
+}
+
+export { AppGeneratorHelper, runtimePrefixFor };