meocord 3.0.0 → 3.2.0

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/builder/primary-entry-point.builder.template

@@ -0,0 +1,26 @@
+import {
+  ApplicationCommandType,
+  ApplicationIntegrationType,
+  EntryPointCommandHandlerType,
+  InteractionContextType,
+} from 'discord.js'
+import { CommandBuilder } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+// Entry point commands have no builder class in @discordjs/builders, so the raw REST
+// body is returned instead — MeoCord registers it as-is. `AppHandler` is what makes
+// Discord send the interaction here; `DiscordLaunchActivity` opens the activity without
+// ever reaching the bot.
+@CommandBuilder(CommandType.PRIMARY_ENTRY_POINT)
+export class SampleCommandBuilder {
+  build() {
+    return {
+      type: ApplicationCommandType.PrimaryEntryPoint as const,
+      name: 'sample-entry-point',
+      description: 'Launch the activity',
+      handler: EntryPointCommandHandlerType.AppHandler,
+      integration_types: [ApplicationIntegrationType.GuildInstall],
+      contexts: [InteractionContextType.Guild],
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+import { AutocompleteInteraction } from 'discord.js'
+import { Controller, Autocomplete } from 'meocord/decorator'
+
+@Controller()
+export class {{className}}AutocompleteController {
+
+  // The option this completes must be declared with `.setAutocomplete(true)` on the
+  // slash command builder, otherwise Discord never sends the interaction.
+  @Autocomplete('sample-slash', 'query')
+  async completeQuery(interaction: AutocompleteInteraction) {
+    const { value } = interaction.options.getFocused(true)
+    const choices = ['alpha', 'beta', 'gamma'].filter(choice => choice.startsWith(value))
+
+    await interaction.respond(choices.map(choice => ({ name: choice, value: choice })))
+  }
+}

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/builder-template/controller/channel-select-menu.controller.template

@@ -0,0 +1,12 @@
+import { ChannelSelectMenuInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@Controller()
+export class {{className}}ChannelSelectMenuController {
+
+  @Command('channel-select-menu', CommandType.CHANNEL_SELECT_MENU)
+  async handleChannelSelectMenu(interaction: ChannelSelectMenuInteraction) {
+    await interaction.reply(`Selected: ${interaction.channels.map(channel => channel.toString()).join(', ')}`)
+  }
+}

package/dist/esm/bin/builder-template/controller/context-menu.controller.template

@@ -1,6 +1,6 @@
 import { UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction } from 'discord.js'
-import { Controller, Command, CommandType } from 'meocord/decorator'
-import { SampleCommandBuilder } from '@src/controllers/context-menu/builders/sample.builder'
+import { Controller, Command } from 'meocord/decorator'
+import { SampleCommandBuilder } from '{{builderImportPath}}'
 
 @Controller()
 export class {{className}}ContextMenuController {

package/dist/esm/bin/builder-template/controller/mentionable-select-menu.controller.template

@@ -0,0 +1,12 @@
+import { MentionableSelectMenuInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@Controller()
+export class {{className}}MentionableSelectMenuController {
+
+  @Command('mentionable-select-menu', CommandType.MENTIONABLE_SELECT_MENU)
+  async handleMentionableSelectMenu(interaction: MentionableSelectMenuInteraction) {
+    await interaction.reply(`Selected ${interaction.users.size} user(s) and ${interaction.roles.size} role(s).`)
+  }
+}

package/dist/esm/bin/builder-template/controller/modal-submit.controller.template

@@ -3,7 +3,7 @@ import { Controller, Command } from 'meocord/decorator'
 import { CommandType } from 'meocord/enum'
 
 @Controller()
-export class {{className}}ModalController {
+export class {{className}}ModalSubmitController {
 
   @Command('submit-modal', CommandType.MODAL_SUBMIT)
   async handleModal(interaction: ModalSubmitInteraction) {

package/dist/esm/bin/builder-template/controller/primary-entry-point.controller.template

@@ -0,0 +1,12 @@
+import { PrimaryEntryPointCommandInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { SampleCommandBuilder } from '{{builderImportPath}}'
+
+@Controller()
+export class {{className}}PrimaryEntryPointController {
+
+  @Command('sample-entry-point', SampleCommandBuilder)
+  async handleEntryPoint(interaction: PrimaryEntryPointCommandInteraction) {
+    await interaction.reply('Launching the activity.')
+  }
+}

package/dist/esm/bin/builder-template/controller/role-select-menu.controller.template

@@ -0,0 +1,12 @@
+import { RoleSelectMenuInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@Controller()
+export class {{className}}RoleSelectMenuController {
+
+  @Command('role-select-menu', CommandType.ROLE_SELECT_MENU)
+  async handleRoleSelectMenu(interaction: RoleSelectMenuInteraction) {
+    await interaction.reply(`Selected: ${interaction.roles.map(role => role.name).join(', ')}`)
+  }
+}

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

@@ -1,6 +1,6 @@
 import { ChatInputCommandInteraction } from 'discord.js'
 import { Controller, Command } from 'meocord/decorator'
-import { SampleCommandBuilder } from '@src/controllers/slash/builders/sample.builder'
+import { SampleCommandBuilder } from '{{builderImportPath}}'
 
 @Controller()
 export class {{className}}SlashController {

package/dist/esm/bin/builder-template/controller/user-select-menu.controller.template

@@ -0,0 +1,12 @@
+import { UserSelectMenuInteraction } from 'discord.js'
+import { Controller, Command } from 'meocord/decorator'
+import { CommandType } from 'meocord/enum'
+
+@Controller()
+export class {{className}}UserSelectMenuController {
+
+  @Command('user-select-menu', CommandType.USER_SELECT_MENU)
+  async handleUserSelectMenu(interaction: UserSelectMenuInteraction) {
+    await interaction.reply(`Selected: ${interaction.users.map(user => user.username).join(', ')}`)
+  }
+}

package/dist/esm/bin/generator.js

@@ -1,4 +1,5 @@
 import { Argument } from 'commander';
+import { ControllerType } from '../enum/controller.enum.js';
 import { ControllerGeneratorHelper } from './helper/controller-generator.helper.js';
 import { Logger } from '../common/logger.js';
 import '../common/theme.js';
@@ -9,15 +10,9 @@ import wait from '../util/wait.util.js';
 class GeneratorCLI {
     register(program) {
         const generatorCommand = program.command('generate').alias('g').description('Generate components');
-        generatorCommand.command('controller').alias('co').description('Generate a controller component').addArgument(new Argument('<type>', 'Type of the controller (e.g., button, context-menu, etc.)').choices([
-            'button',
-            'context-menu',
-            'message',
-            'modal-submit',
-            'reaction',
-            'select-menu',
-            'slash'
-        ])).addArgument(new Argument('<name>', 'Name of the controller')).action(async (type, name)=>{
+        generatorCommand.command('controller').alias('co').description('Generate a controller component').addArgument(// Derived from the enum rather than listed by hand, so a new controller kind
+        // cannot be added to the framework and stay unreachable from the CLI.
+        new Argument('<type>', 'Type of the controller (e.g., button, context-menu, etc.)').choices(Object.values(ControllerType))).addArgument(new Argument('<name>', 'Name of the controller')).action(async (type, name)=>{
             await this.handleGenerateComponent({
                 component: 'controller',
                 type: type,

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 };

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

@@ -14,7 +14,7 @@ class ControllerGeneratorHelper {
    */ generateController(args, type) {
         const { parts, kebabCaseName, className } = validateAndFormatName(args.controllerName);
         const controllerDir = path.join(process.cwd(), 'src', 'controllers', type, ...parts);
-        const template = this.buildControllerTemplate(className, type);
+        const template = this.buildControllerTemplate(className, type, parts);
         this.generateControllerStructure(controllerDir, kebabCaseName, className, type, template);
     }
     /**
@@ -23,8 +23,8 @@ class ControllerGeneratorHelper {
    * @param type - The type of the controller, defined in the `ControllerType` enum.
    * @returns The populated template string for the controller.
    * @throws Will throw an error if the controller type is unsupported.
-   */ buildControllerTemplate(className, type) {
-        const templateConfig = this.getTemplateConfig(type, className);
+   */ buildControllerTemplate(className, type, parts = []) {
+        const templateConfig = this.getTemplateConfig(type, className, parts);
         if (!templateConfig) {
             throw new Error(`Unsupported controller type: ${type}`);
         }
@@ -35,22 +35,38 @@ class ControllerGeneratorHelper {
    * @param type - The type of the controller, defined in the `ControllerType` enum.
    * @param className - The name of the controller class.
    * @returns An object containing the template path and variables, or `undefined` if not found.
-   */ getTemplateConfig(type, className) {
+   */ getTemplateConfig(type, className, parts = []) {
         const baseDir = path.resolve(__dirname$1, '..', 'builder-template', 'controller');
         const templates = {
             [ControllerType.BUTTON]: 'button.controller.template',
             [ControllerType.MODAL_SUBMIT]: 'modal-submit.controller.template',
             [ControllerType.SELECT_MENU]: 'select-menu.controller.template',
+            [ControllerType.USER_SELECT_MENU]: 'user-select-menu.controller.template',
+            [ControllerType.ROLE_SELECT_MENU]: 'role-select-menu.controller.template',
+            [ControllerType.MENTIONABLE_SELECT_MENU]: 'mentionable-select-menu.controller.template',
+            [ControllerType.CHANNEL_SELECT_MENU]: 'channel-select-menu.controller.template',
             [ControllerType.REACTION]: 'reaction.controller.template',
             [ControllerType.MESSAGE]: 'message.controller.template',
             [ControllerType.CONTEXT_MENU]: 'context-menu.controller.template',
-            [ControllerType.SLASH]: 'slash.controller.template'
+            [ControllerType.SLASH]: 'slash.controller.template',
+            [ControllerType.AUTOCOMPLETE]: 'autocomplete.controller.template',
+            [ControllerType.PRIMARY_ENTRY_POINT]: 'primary-entry-point.controller.template'
         };
         const template = templates[type] ? path.resolve(baseDir, templates[type]) : undefined;
+        // The builder is written beside the controller, so a nested controller name moves
+        // it too. Hard-coding `@src/controllers/<type>/builders/...` only ever pointed at
+        // the top-level one, which for a nested name does not exist.
+        const builderImportPath = [
+            '@src/controllers',
+            type,
+            ...parts,
+            'builders/sample.builder'
+        ].join('/');
         return template ? {
             template,
             variables: {
-                className
+                className,
+                builderImportPath
             }
         } : undefined;
     }
@@ -99,7 +115,8 @@ class ControllerGeneratorHelper {
         const baseDir = path.resolve(__dirname$1, '..', 'builder-template', 'builder');
         const templates = {
             [ControllerType.CONTEXT_MENU]: 'context-menu.builder.template',
-            [ControllerType.SLASH]: 'slash.builder.template'
+            [ControllerType.SLASH]: 'slash.builder.template',
+            [ControllerType.PRIMARY_ENTRY_POINT]: 'primary-entry-point.builder.template'
         };
         const template = templates[type] ? path.resolve(baseDir, templates[type]) : undefined;
         return template ? {