meocord 3.1.0 → 3.2.0

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/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.')
+  }
+}

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

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

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

@@ -0,0 +1,28 @@
+import { MessageHandler, Controller } from 'meocord/decorator'
+import { Message } from 'discord.js'
+import { Logger } from 'meocord/common'
+
+@Controller()
+export class SampleMessageController {
+  private readonly logger = new Logger(SampleMessageController.name)
+
+  @MessageHandler('baka')
+  @MessageHandler('Baka')
+  async baka(message: Message): Promise<void> {
+    try {
+      await message.reply(`You Baka!`)
+    } catch (error) {
+      this.logger.error('Error replying to command', error)
+    }
+  }
+
+  @MessageHandler()
+  async handleGeneralMessage(message: Message): Promise<void> {
+    try {
+      this.logger.info(`Received message: ${message.content}`)
+      // TODO: Implements your message handler logic here
+    } catch (error) {
+      this.logger.error('Error handling the message', error)
+    }
+  }
+}

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

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

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

@@ -0,0 +1,13 @@
+import { ModalSubmitInteraction } 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 SampleModalSubmitController {
+  @Command('submit-modal', CommandType.MODAL_SUBMIT)
+  @UseGuard(RateLimitGuard)
+  async handleModal(interaction: ModalSubmitInteraction) {
+    await interaction.reply('Modal submitted!')
+  }
+}

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

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