meocord 3.1.0 → 3.2.1

package/README.md

@@ -25,6 +25,7 @@
 - [Testing](#testing)
 - [Deployment](#deployment)
 - [Contributing](#contributing)
+- [Release Notes](#release-notes)
 - [License](#license)
 
 ---
@@ -66,30 +67,57 @@ npx meocord create <your-app-name> --use-pnpm
 npx meocord create <your-app-name> --use-yarn
 ```
 
-Set your Discord bot token in `meocord.config.ts`, then start the bot:
+The generated project is named after what you passed, pins the framework version that
+created it, and comes with a working slash command, button, select menu, modal, context
+menu, message and reaction controller, plus a guard, a service and a spec for each.
+
+Add your bot token and start:
 
 ```shell
-npx meocord start --dev   # development with live-reload
+cd <your-app-name>
+cp .env.example .env       # then put your token in DISCORD_TOKEN
+npx meocord start --dev    # development with live-reload
 npx meocord start --build --prod  # production build + start
 ```
 
+The token is read from the environment rather than written into `meocord.config.ts`,
+which is committed — `.env` is gitignored so a token cannot be pushed by accident.
+Building needs no token; only starting does.
+
 ### Quick Example
 
-A minimal slash command controller:
+A minimal slash command. A command Discord knows about needs a builder — that is what gets registered. The
+builder receives the name from `@Command`, so the two cannot drift apart:
 
 ```typescript
-import { Controller, Command, UseGuard } from 'meocord/decorator'
+import { SlashCommandBuilder } from 'discord.js'
+import { CommandBuilder } from 'meocord/decorator'
 import { CommandType } from 'meocord/enum'
+
+@CommandBuilder(CommandType.SLASH)
+export class GreetingCommandBuilder {
+  build(commandName: string) {
+    return new SlashCommandBuilder()
+      .setName(commandName)
+      .setDescription('Greets someone')
+      .addStringOption(option => option.setName('name').setDescription('Who to greet').setRequired(true))
+  }
+}
+```
+
+```typescript
+import { Controller, Command, UseGuard } from 'meocord/decorator'
 import { type ChatInputCommandInteraction } from 'discord.js'
-import { RateLimiterGuard } from '@src/guards/rate-limiter.guard.js'
+import { GreetingCommandBuilder } from '@src/controllers/slash/builders/greeting.builder.js'
+import { RateLimitGuard } from '@src/guards/rate-limit.guard.js'
 import { GreetingService } from '@src/services/greeting.service.js'
 
 @Controller()
 export class GreetingSlashController {
   constructor(private readonly greetingService: GreetingService) {}
 
-  @Command('greet', CommandType.SLASH)
-  @UseGuard({ provide: RateLimiterGuard, params: { limit: 3, window: 10_000 } })
+  @Command('greet', GreetingCommandBuilder)
+  @UseGuard({ provide: RateLimitGuard, params: { limit: 3, windowInSeconds: 10 } })
   async greet(interaction: ChatInputCommandInteraction) {
     const name = interaction.options.getString('name', true)
     const message = await this.greetingService.buildGreeting(name)
@@ -126,6 +154,10 @@ export class App {}
 
 ```
 .
+├── README.md
+├── .env.example
+├── .gitignore
+├── .prettierrc.mjs
 ├── meocord.config.ts
 ├── eslint.config.ts
 ├── vitest.config.ts
@@ -231,18 +263,35 @@ npx meocord --help
 | `generate` | `g`   | Scaffold controllers, services, guards |
 | `show`     | —     | Display framework info                 |
 
-**Common flags:**
+Every command's own flags:
+
+| Command    | Flags                                                   |
+| ---------- | ------------------------------------------------------- |
+| `create`   | `--use-npm` · `--use-yarn` · `--use-pnpm` · `--use-bun` |
+| `build`    | `-d, --dev` · `-p, --prod`                              |
+| `start`    | `-b, --build` · `-d, --dev` · `-p, --prod`              |
+| `show`     | `-w, --warranty` · `-c, --license`                      |
+| `generate` | see the sub-commands below                              |
+
+`meocord -V` / `--version` prints the installed version.
+
+`start` accepts one environment variable, `MEOCORD_RUNTIME`, which pins the binary the application is run with — see [Which runtime the bot runs on](#which-runtime-the-bot-runs-on).
 
 ```shell
 npx meocord build --prod          # production build
-npx meocord build --dev           # development build
 npx meocord start --dev           # dev mode with live-reload
 npx meocord start --build --prod  # production build + start
-npx meocord g co slash "profile"  # generate a slash controller
-npx meocord g --help              # list all generator sub-commands
 ```
 
-### Generating a controller
+### Generators
+
+| Sub-command  | Alias | Generates                           |
+| ------------ | ----- | ----------------------------------- |
+| `controller` | `co`  | a controller, its spec, its builder |
+| `service`    | `s`   | a service and its spec              |
+| `guard`      | `gu`  | a guard and its spec                |
+
+#### Controllers
 
 ```shell
 npx meocord g co <type> <name>
@@ -825,7 +874,7 @@ import {
 import { ChatInputCommandInteraction } from 'discord.js'
 import { GreetingSlashController } from '@src/controllers/slash/greeting.slash.controller.js'
 import { GreetingService } from '@src/services/greeting.service.js'
-import { RateLimiterGuard } from '@src/guards/rate-limiter.guard.js'
+import { RateLimitGuard } from '@src/guards/rate-limit.guard.js'
 
 describe('GreetingSlashController', () => {
   let controller: GreetingSlashController
@@ -894,6 +943,62 @@ Start in production:
 npx meocord start --prod
 ```
 
+### Which runtime the bot runs on
+
+`start` runs the bot on **the runtime you launched it with**. There is nothing to configure and no config key to set — if you typed `bun`, you get a bun process:
+
+```shell
+bun run start          # dist/main.js runs under bun
+npm run start          # dist/main.js runs under node
+```
+
+Two signals decide it, most explicit first: the runtime executing the CLI, and — when the CLI itself was handed to node — the runner that launched it. `bun run` honours the bin's `#!/usr/bin/env node` shebang, so bun sets `npm_execpath` to its own binary and that is what the bot is spawned with. npm, pnpm and yarn point it at a `.js` file instead, which cannot run the bundle, so those fall through to node as expected.
+
+That matters for more than tidiness. Pinning `node` would oblige a bun-only image to install a second runtime purely to launch, or to carry `--bun` on every command. It also decides the allocator: for a bot doing heavy native work — canvas rendering through a napi module, say — glibc's malloc and bun's mimalloc produce very different resident-memory curves on the same workload, because they differ in how eagerly freed pages go back to the OS.
+
+Development works the same way. The watcher runs the bundle through the same command production does, so a runtime that works in `--dev` cannot quietly differ from the one that ships.
+
+#### Running the CLI itself on bun
+
+The resolution above decides what the _bot_ runs on. The CLI process is decided earlier,
+by the interpreter line `#!/usr/bin/env node`, which nothing in the package can influence
+— it is read before any of the program exists. On a machine with no node at all,
+invoking the CLI directly fails before it starts:
+
+```
+$ meocord start --prod
+env: node: No such file or directory
+```
+
+That line stays as it is because Windows depends on it: npm there never runs the file
+through its shebang, it parses the line and writes a `.cmd` invoking the program named in
+it. `#!/usr/bin/env node` yields `node`; anything else yields a program Windows cannot
+resolve.
+
+So on a bun-only image, tell bun to ignore the line. Either per command:
+
+```shell
+bun --bun meocord start --prod
+```
+
+or once for the project, which is what a bun-only Dockerfile wants:
+
+```toml
+# bunfig.toml
+[run]
+bun = true
+```
+
+Then plain `bun run start` runs the CLI and the bot on bun, and node need not exist.
+
+#### Pinning a specific binary
+
+To override both signals — a particular install, or a different runtime for comparison — set `MEOCORD_RUNTIME`:
+
+```shell
+MEOCORD_RUNTIME=/usr/local/bin/bun npm run start
+```
+
 ---
 
 ## Contributing
@@ -902,9 +1007,27 @@ npx meocord start --prod
 2. Create a feature branch: `git checkout -b feat/your-feature`
 3. Commit with conventional commits: `git commit -m "feat: add X"`
 4. Run `bun run lint` and `bun run test` before pushing
-5. Push and open a pull request against `main`
+5. If you touched anything under `src/bin/`, also run `bun run build && bun run verify:generated`
+6. Push and open a pull request against `main`
+
+Include a description of what changed and why, and add tests for any new behaviour.
+
+`verify:generated` generates one controller of every type through the built CLI — flat and nested, in separate throwaway projects — and typechecks the result against the published package. Rendering a template says nothing about whether the code it produces compiles, and two bugs lived behind exactly that gap. It runs in CI as part of the Build job, so you do not have to remember it; running it locally is just faster than waiting.
+
+### Commit messages and releases
+
+Commit messages drive versioning through [semantic-release](https://semantic-release.gitbook.io/). Only these publish:
+
+| Prefix                         | Release |
+| ------------------------------ | ------- |
+| `feat:`                        | minor   |
+| `fix:`                         | patch   |
+| `perf:`                        | patch   |
+| `BREAKING CHANGE:` in the body | major   |
+
+Everything else — `docs:`, `test:`, `ci:`, `chore:`, `refactor:`, `style:` — lands on `main` without publishing and ships with whatever releasable commit comes next.
 
-Include a description of what changed and why, and add tests for any new behaviour. Use `fix:` / `feat:` / `docs:` prefixes so [semantic-release](https://semantic-release.gitbook.io/) can version correctly — `test:` commits do not trigger a release.
+Pick the prefix by what reaches the installed package, not by which file you edited. JSDoc is compiled into the published `.d.ts` and is what a user reads in their editor, so correcting a wrong `@example` is a `fix:` even though you only touched a comment. A README-only change is `docs:`.
 
 ---
 

package/dist/cjs/core/index.cjs

@@ -26,23 +26,44 @@ const createErrorEmbed = (description)=>{
     return embed;
 };
 
+/** What Discord assumes a command body is when it carries no type of its own. */ const DEFAULT_APPLICATION_COMMAND_TYPE = discord_js.ApplicationCommandType.ChatInput;
 /**
- * The name a builder registers under, which is what Discord deduplicates on.
+ * The body a builder registers, which is what Discord sees.
  *
- * Read from the built payload rather than from the `@Command` argument: a builder is
- * free to name the command something other than the string it was handed, and it is
- * the payload Discord sees.
- */ function commandNameOf(builder) {
+ * Read from the built payload rather than from the `@Command` arguments: a builder is
+ * free to describe the command differently from the strings it was handed.
+ */ function payloadOf(builder) {
     try {
-        const json = typeof builder.toJSON === 'function' ? builder.toJSON() : builder;
-        return typeof json?.name === 'string' ? json.name : undefined;
+        return typeof builder.toJSON === 'function' ? builder.toJSON() : builder;
     } catch  {
         // A builder missing a required field throws from toJSON. Surfacing that is the
         // registration call's job, where it is reported against the command Discord
         // rejected -- deduplication should not be what turns it into a startup crash.
-        return undefined;
+        return {};
     }
 }
+/** The name a builder registers under. */ function commandNameOf(builder) {
+    const { name } = payloadOf(builder);
+    return typeof name === 'string' ? name : undefined;
+}
+/**
+ * The application command type a builder registers as.
+ *
+ * A slash builder may leave the field out, so an absent type is read as the chat input
+ * one Discord would infer — which keeps untyped slash builders colliding with each
+ * other rather than each claiming a key of its own.
+ */ function commandTypeOf(builder) {
+    const { type } = payloadOf(builder);
+    return typeof type === 'number' ? type : DEFAULT_APPLICATION_COMMAND_TYPE;
+}
+/**
+ * The identity Discord gives a command.
+ *
+ * The numeric type leads, so the two halves can never be read apart wrongly: everything
+ * before the first separator is the type, everything after it is the name.
+ */ function registrationKey(builder, fallbackName) {
+    return `${commandTypeOf(builder)}:${commandNameOf(builder) ?? fallbackName}`;
+}
 class MeoCordApp {
     /**
    * Runs an event handler so a failure inside it cannot take the process down.
@@ -109,11 +130,13 @@ class MeoCordApp {
         }
     }
     async registerCommands() {
-        // Keyed by registered name: a command whose subcommands live in separate methods
-        // declares the same name more than once, and sending its builder twice makes
-        // Discord reject the whole payload. The first builder wins, and a second one that
-        // is not the same object is reported rather than silently dropped.
-        const buildersByName = new Map();
+        // Keyed by type and name together, because that pair is what Discord treats as one
+        // command: a user context menu and a message context menu are free to share a name,
+        // and keying on the name alone would drop one of them from the payload. Within a
+        // single type the name is unique, so a command whose subcommands live in separate
+        // methods still contributes its builder once — sending it twice makes Discord
+        // reject the whole payload.
+        const buildersByCommand = new Map();
         for (const controllerClass of this.controllerClasses){
             const instance = this.getInstance(controllerClass);
             const commandMap = controller_decorator.getCommandMap(instance);
@@ -122,18 +145,18 @@ class MeoCordApp {
                 if (!Array.isArray(commandMetadataArray)) continue;
                 for (const { builder, type } of commandMetadataArray){
                     if (!(type in enum_index.CommandType) || !builder) continue;
-                    const registeredName = commandNameOf(builder) ?? commandName;
-                    const existing = buildersByName.get(registeredName);
+                    const key = registrationKey(builder, commandName);
+                    const existing = buildersByCommand.get(key);
                     if (existing === undefined) {
-                        buildersByName.set(registeredName, builder);
+                        buildersByCommand.set(key, builder);
                     } else if (existing !== builder) {
-                        this.logger.warn(`Command "${registeredName}" is built more than once; only the first builder is registered. ` + `Declare the builder on one @Command and give the others the plain CommandType.`);
+                        this.logger.warn(`Command "${commandNameOf(builder) ?? commandName}" is built more than once for the same ` + `application command type; only the first builder is registered. Two builders of one type ` + `cannot both own a name, so declare the builder on a single @Command and give the others ` + `the plain CommandType.`);
                     }
                 }
             }
         }
         const builders = [
-            ...buildersByName.values()
+            ...buildersByCommand.values()
         ];
         try {
             if (this.bot.application) {

package/dist/cjs/decorator/index.cjs

@@ -154,7 +154,7 @@ export class ButtonInteractionGuard implements GuardInterface {
  * @example
  * ```typescript
  * // Method-level usage
- * @Command('profile-{id}', CommandType.BUTTON)
+ * @Command('profile/{id}', CommandType.BUTTON)
  * @UseGuard(
  *   { provide: RateLimiterGuard, params: { limit: 2, window: 3000 } },
  *   ButtonInteractionGuard

package/dist/esm/bin/app-template/README.md.template

@@ -0,0 +1,61 @@
+# {{displayName}}
+
+A Discord bot built with [MeoCord](https://github.com/l7aromeo/meocord).
+
+## Setup
+
+Copy the example environment file and add your bot token:
+
+```shell
+cp .env.example .env
+```
+
+`.env` is gitignored. Never commit a real token — if one is pushed, reset it in the
+[Discord developer portal](https://discord.com/developers/applications) rather than
+rewriting history.
+
+## Running
+
+```shell
+{{packageManager}} run start:dev    # watch mode, rebuilds and restarts on change
+{{packageManager}} run start:prod   # production
+```
+
+The bot runs on whichever runtime you launch it with — launch with bun and it is a bun
+process, launch with node and it is a node process.
+
+## Building
+
+```shell
+{{packageManager}} run build:dev
+{{packageManager}} run build:prod
+```
+
+## Generating components
+
+```shell
+npx meocord g co slash "profile"     # a slash controller, its spec and its builder
+npx meocord g s "profile"            # a service
+npx meocord g gu "rate-limit"        # a guard
+npx meocord g --help                 # every generator
+```
+
+Register whatever you generate in the `controllers` array in `src/app.ts` — controllers
+are wired up by that list, not by where they sit on disk.
+
+## Testing
+
+```shell
+{{packageManager}} run test
+{{packageManager}} run test:coverage
+```
+
+`meocord/testing` provides `MeoCordTestingModule` for building a controller with its
+dependencies, plus `createMockInteraction` and friends for driving it without a Discord
+connection.
+
+## Linting
+
+```shell
+{{packageManager}} run lint
+```

package/dist/esm/bin/app-template/_env.example.template

@@ -0,0 +1,2 @@
+# Copy to .env and fill in. Never commit the real token.
+DISCORD_TOKEN=

package/dist/esm/bin/app-template/_gitignore.template

@@ -0,0 +1,22 @@
+dist
+coverage
+
+/node_modules
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+.idea
+.vscode/*
+
+.env*
+!.env.example
+.DS_Store

package/dist/esm/bin/app-template/_prettierrc.mjs.template

@@ -0,0 +1,10 @@
+export default {
+  bracketSpacing: true,
+  bracketSameLine: true,
+  singleQuote: true,
+  trailingComma: 'all',
+  arrowParens: 'avoid',
+  semi: false,
+  endOfLine: 'lf',
+  printWidth: 120,
+}

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

@@ -0,0 +1,25 @@
+import unusedImports from 'eslint-plugin-unused-imports'
+import meocordESLint, { typescriptConfig } from 'meocord/eslint'
+
+const customConfig = {
+  ...typescriptConfig,
+  plugins: {
+    ...typescriptConfig.plugins,
+    'unused-imports': unusedImports,
+  },
+  rules: {
+    ...typescriptConfig.rules,
+    'unused-imports/no-unused-imports': 'error',
+    'unused-imports/no-unused-vars': [
+      'error',
+      {
+        vars: 'all',
+        varsIgnorePattern: '^_',
+        args: 'after-used',
+        argsIgnorePattern: '^_',
+      },
+    ],
+  },
+}
+
+export default [...meocordESLint, customConfig]

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

@@ -0,0 +1,25 @@
+import 'dotenv/config'
+import { type MeoCordConfig } from 'meocord/interface'
+
+export default {
+  appName: '{{displayName}}',
+  // Read from the environment rather than written here: this file is committed, and a
+  // token pasted into it is a token pushed to the remote. Copy .env.example to .env.
+  discordToken: process.env.DISCORD_TOKEN!,
+  webpack: config => {
+    config.module.rules?.push({
+      test: /\.(md|html)$/i,
+      type: 'asset/source',
+    })
+    config.module.rules?.push({
+      test: /\.(gif|jpg|jpeg|png|svg|woff|woff2|eot|ttf|otf)$/i,
+      type: 'asset/resource',
+      exclude: /node_modules/,
+      generator: {
+        filename: 'assets/[name][ext]',
+      },
+    })
+
+    return config
+  },
+} satisfies MeoCordConfig

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

@@ -0,0 +1,38 @@
+{
+  "name": "{{appName}}",
+  "version": "0.1.0",
+  "description": "",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "build:dev": "{{runtimePrefix}}meocord build --dev",
+    "build:prod": "{{runtimePrefix}}meocord build --prod",
+    "start:dev": "{{runtimePrefix}}meocord start --dev",
+    "start:prod": "{{runtimePrefix}}meocord start --prod",
+    "lint": "eslint --fix && tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "discord.js": "^14.27.0",
+    "dotenv": "^17.2.4",
+    "meocord": "^{{version}}"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@typescript-eslint/parser": "^8.58.1",
+    "@vitest/coverage-istanbul": "^4.1.10",
+    "eslint": "^10.2.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import-x": "^4.16.2",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "globals": "^17.5.0",
+    "prettier": "^3.8.2",
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.1",
+    "unplugin-swc": "^1.5.7",
+    "vitest": "^4.1.10"
+  }
+}

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

@@ -0,0 +1,44 @@
+import { GatewayIntentBits, Partials, ActivityType } from 'discord.js'
+import { MeoCord } from 'meocord/decorator'
+import { SampleSlashController } from '@src/controllers/slash/sample.slash.controller'
+import { SampleSelectMenuController } from '@src/controllers/select-menu/sample.select-menu.controller'
+import { SampleButtonController } from '@src/controllers/button/sample.button.controller'
+import { SampleMessageController } from '@src/controllers/message/sample.message.controller'
+import { SampleReactionController } from '@src/controllers/reaction/sample.reaction.controller'
+import { SampleContextMenuController } from '@src/controllers/context-menu/sample.context-menu.controller'
+import { SampleModalSubmitController } from '@src/controllers/modal-submit/sample.modal-submit.controller'
+
+@MeoCord({
+  controllers: [
+    // Slash Commands
+    SampleSlashController,
+    // Select Menu
+    SampleSelectMenuController,
+    // Buttons
+    SampleButtonController,
+    // Message
+    SampleMessageController,
+    // Reactions
+    SampleReactionController,
+    // Context Menu
+    SampleContextMenuController,
+    // Modal Submit
+    SampleModalSubmitController,
+  ],
+  clientOptions: {
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.GuildMessageReactions,
+      GatewayIntentBits.MessageContent,
+    ],
+    partials: [Partials.Message, Partials.Reaction],
+  },
+  activities: [
+    {
+      name: ``,
+      type: ActivityType.Custom,
+    },
+  ],
+})
+export default class App {}

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

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

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

@@ -0,0 +1,19 @@
+import { ButtonInteraction } from 'discord.js'
+import { Controller, Command, UseGuard } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+import { RateLimitGuard } from '@src/guards/rate-limit.guard'
+
+@Controller()
+export class SampleButtonController {
+  @Command('button-click', CommandType.BUTTON)
+  @UseGuard(RateLimitGuard)
+  async handleButton(interaction: ButtonInteraction) {
+    await interaction.reply('Button clicked!')
+  }
+
+  @Command('button-with/{id}', CommandType.BUTTON)
+  @UseGuard({ provide: RateLimitGuard, params: { limit: 2, windowInSeconds: 60 } })
+  async handleButtonWithId(interaction: ButtonInteraction, { id }: { id: string }) {
+    await interaction.reply(`Button with id: ${id} clicked!`)
+  }
+}

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

@@ -0,0 +1,10 @@
+import { ContextMenuCommandBuilder, ApplicationCommandType } from 'discord.js'
+import { CommandBuilder } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@CommandBuilder(CommandType.CONTEXT_MENU)
+export class SampleCommandBuilder {
+  build() {
+    return new ContextMenuCommandBuilder().setName('sample-context-menu').setType(ApplicationCommandType.User)
+  }
+}

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

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

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

@@ -0,0 +1,13 @@
+import { UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction } from 'discord.js'
+import { Controller, Command, UseGuard } from 'meocord/decorator'
+import { SampleCommandBuilder } from '@src/controllers/context-menu/builders/sample.builder'
+import { RateLimitGuard } from '@src/guards/rate-limit.guard'
+
+@Controller()
+export class SampleContextMenuController {
+  @Command('sample-context-menu', SampleCommandBuilder)
+  @UseGuard(RateLimitGuard)
+  async handleContextMenu(interaction: UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction) {
+    await interaction.reply('This is sample reply of context menu command.')
+  }
+}