meocord 1.2.1 → 1.2.2

package/dist/cjs/core/index.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+require('reflect-metadata');
+var theme = require('../_shared/theme-BdtbtMZX.cjs');
+var meocord_app = require('../_shared/meocord.app-CHjdCAA_.cjs');
+require('inversify');
+require('discord.js');
+require('path');
+require('fs');
+require('jiti');
+require('node:util');
+require('dayjs');
+require('dayjs/plugin/utc.js');
+require('dayjs/plugin/timezone.js');
+require('chalk');
+require('../enum/index.cjs');
+require('lodash-es');
+
+class MeoCordFactory {
+    static create(target) {
+        const container = Reflect.getMetadata('inversify:container', target);
+        if (!container) {
+            if (typeof target === 'function') {
+                this.logger.error(`No container found for class: ${target.name}`);
+            } else {
+                this.logger.error('No container found for the provided target.');
+            }
+            throw new Error('No container found on the target class.');
+        }
+        return meocord_app.mainContainer.get(meocord_app.MeoCordApp);
+    }
+}
+MeoCordFactory.logger = new theme.Logger();
+
+exports.MeoCordFactory = MeoCordFactory;

package/dist/cjs/decorator/index.cjs

@@ -0,0 +1,360 @@
+'use strict';
+
+require('reflect-metadata');
+var meocord_app = require('../_shared/meocord.app-CHjdCAA_.cjs');
+var inversify = require('inversify');
+var discord_js = require('discord.js');
+var theme = require('../_shared/theme-BdtbtMZX.cjs');
+require('../enum/index.cjs');
+require('lodash-es');
+require('node:util');
+require('dayjs');
+require('dayjs/plugin/utc.js');
+require('dayjs/plugin/timezone.js');
+require('path');
+require('fs');
+require('jiti');
+require('chalk');
+
+/**
+ * `@Service()` decorator to mark a class as a service that can be injected into controllers or used as standalone services.
+ *
+ * @example
+ * ```typescript
+ * @Service()
+ * class MyService {
+ *   constructor(private anotherService: AnotherService) {}
+ *
+ *   doSomething() {
+ *     this.anotherService.alsoDoSomething()
+ *     console.log('Hello, World!')
+ *   }
+ * }
+ * ```
+ * @returns A decorator function to apply to the class.
+ */ function Service() {
+    return function(target) {
+        // Check if the class is already injectable; if not, make it injectable dynamically
+        if (!Reflect.hasMetadata('inversify:injectable', target)) {
+            inversify.injectable()(target);
+        }
+        // Check if the class is already injectable; if not, make it injectable dynamically
+        if (!meocord_app.mainContainer.isBound(target)) {
+            // Bind the target class to the container in a singleton scope
+            meocord_app.mainContainer.bind(target).toSelf().inSingletonScope();
+        }
+        // Recursively bind dependencies
+        bindDependencies$1(target);
+    };
+}
+function bindDependencies$1(target) {
+    // Get the constructor parameter types using Reflect metadata
+    const dependencies = Reflect.getMetadata('design:paramtypes', target) || [];
+    dependencies.forEach((dep)=>{
+        // Bind the dependency if not already bound
+        if (!meocord_app.mainContainer.isBound(dep)) {
+            if (dep.name === discord_js.Client.name) return;
+            try {
+                // Check if the class is already injectable; if not, make it injectable dynamically
+                if (!Reflect.hasMetadata('inversify:injectable', dep)) {
+                    inversify.injectable()(dep);
+                }
+                meocord_app.mainContainer.bind(dep).toSelf().inSingletonScope();
+                bindDependencies$1(dep); // Recur for the dependencies of the current dependency
+            } catch (error) {
+                console.warn(`Could not bind dependency: ${dep?.name || dep}`, error);
+            }
+        }
+    });
+}
+
+/**
+ * This decorator is used to mark a class as a Discord command builder that later can be registered on the `@Command` decorator.
+ * It defines the command type using metadata and dynamically makes the class injectable if it isn't already.
+ *
+ * @example
+ * ```typescript
+ * @CommandBuilder(CommandType.SLASH)
+ * export class MySlashCommand implements CommandBuilderBase {
+ *   build(commandName: string): SlashCommandBuilder {
+ *     return new SlashCommandBuilder().setName(commandName).setDescription('A sample slash command')
+ *   }
+ * }
+ *```
+ *
+ * @param commandType - The type of the command, specified from the `CommandType` enum.
+ * @returns A decorator function that makes the target class injectable
+ *          and assigns the `commandType` metadata.
+ */ function CommandBuilder(commandType) {
+    return function(target) {
+        // Check if the class is already injectable; if not, make it injectable dynamically
+        if (!Reflect.hasMetadata('inversify:injectable', target)) {
+            inversify.injectable()(target);
+        }
+        // Define the command type metadata for the target class
+        Reflect.defineMetadata('commandType', commandType, target);
+    };
+}
+
+function isValidContext(context) {
+    return context instanceof discord_js.BaseInteraction || context instanceof discord_js.Message || context instanceof discord_js.MessageReaction;
+}
+function applyGuards(descriptor, guards, propertyKey) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+        const [context] = args;
+        if (!isValidContext(context)) {
+            throw new Error(`The first argument of ${String(propertyKey)} must be an instance of Interaction, Message, or MessageReaction.`);
+        }
+        // Iterate over each guard and check if it allows the method to proceed
+        for (const guard of guards){
+            let guardInstance;
+            if (isGuardWithParams(guard)) {
+                const { provide, params } = guard;
+                guardInstance = meocord_app.mainContainer.get(provide, {
+                    autobind: true
+                });
+                // Inject the parameters into the guard instance
+                Object.assign(guardInstance, params);
+            } else {
+                // Resolve guard without parameters
+                guardInstance = meocord_app.mainContainer.get(guard, {
+                    autobind: true
+                });
+            }
+            // Ensure the guard has the necessary method `canActivate`
+            if (!guardInstance.canActivate) {
+                throw new Error(`Guard ${guard.constructor.name} applied to ${String(propertyKey)} does not have a valid canActivate method.`);
+            }
+            // Check if the guard allows the method to proceed
+            const canActivate = await guardInstance.canActivate(...args);
+            if (!canActivate) {
+                return; // Prevent method execution if the guard fails
+            }
+        }
+        // Call the original method if all guards pass
+        return originalMethod.apply(this, args);
+    };
+}
+/**
+ * `@Guard()` decorator to mark a class as a Guard that later can be added on `@UseGuard` decorator.
+ *
+ * @example
+ * ```typescript
+ * @Guard()
+export class ButtonInteractionGuard implements GuardInterface {
+  private readonly logger = new Logger(ButtonInteractionGuard.name)
+
+  async canActivate(context: ButtonInteraction, { ownerId }: { ownerId: string }): Promise<boolean> {
+    if (context.user.id !== ownerId) {
+      this.logger.error(
+        `User with id ${context.user.id} is not allowed to use this command that initiated by user with id ${ownerId}.`,
+      )
+      const embed = generateErrorEmbed(
+        `Hi <@${context.user.id}>, this command can only be used by the person who initiated it: <@${ownerId}>.`,
+      )
+      await context.reply({
+        embeds: [embed],
+        flags: MessageFlagsBitField.Flags.Ephemeral,
+      })
+      return false
+    }
+    return true
+  }
+}
+ * ```
+ */ function Guard() {
+    return function(target) {
+        // Check if the class is already injectable; if not, make it injectable dynamically
+        if (!Reflect.hasMetadata('inversify:injectable', target)) {
+            inversify.injectable()(target);
+        }
+        meocord_app.mainContainer.bind(target).toSelf().inTransientScope();
+        // Bind any dependencies that the guard requires
+        const injectables = Reflect.getMetadata('design:paramtypes', target) || [];
+        injectables.forEach((dep)=>{
+            if (!meocord_app.mainContainer.isBound(dep)) {
+                meocord_app.mainContainer.bind(dep).toSelf().inSingletonScope();
+            }
+        });
+    };
+}
+/**
+ * Type guard to check if the object is a GuardWithParams.
+ * This function helps to check whether a guard is parameterized or not.
+ *
+ * @param guard - The guard to check.
+ * @returns `true` if the guard has parameters, otherwise `false`.
+ */ function isGuardWithParams(guard) {
+    return typeof guard === 'object' && 'provide' in guard && 'params' in guard;
+}
+/**
+ * `@UseGuard()` decorator to apply one or more guards to methods.
+ * Guards are used to handle permission checks before executing a method.
+ * Each guard must use `@Guard` decorator and implement the `canActivate` method, which determines
+ * whether the method should be allowed to execute based on the provided context (Interaction, Message, or Reaction) and arguments.
+ * This decorator ensures that all guards pass validation before calling the original method.
+ * Supports guards that are parameterized (accepting additional parameters).
+ *
+ * @param guards - One or more guard classes to apply. These can be regular guards or guards with additional parameters.
+ *                 - If providing a guard with parameters, it should be an object with:
+ *                   - `provide`: The guard class to instantiate. Must implement `GuardInterface`.
+ *                   - `params`: A record of key-value pairs to be passed as additional properties to the guard instance.
+ * @returns A method decorator function that applies the guards to the method.
+ *
+ * @example
+ * ```typescript
+ * // Method-level usage
+ * @Command('profile-{id}', CommandType.BUTTON)
+ * @UseGuard(
+ *   { provide: RateLimiterGuard, params: { limit: 2, window: 3000 } },
+ *   ButtonInteractionGuard
+ * )
+ * async showProfileById(interaction: ButtonInteraction, { id }: { id: string }) {
+ *   await interaction.reply(`Profile ID: ${id}`)
+ * }
+ *
+ * // Class-level usage
+ * @Controller()
+ * @UseGuard(GlobalGuard)
+ * class MyController {
+ *   @Command('ping', CommandType.SLASH)
+ *   async ping(interaction: ChatInputCommandInteraction) {
+ *     await interaction.reply('Pong!')
+ *   }
+ * }
+ * ```
+ */ function UseGuard(...guards) {
+    return function(target, propertyKey, descriptor) {
+        if (descriptor && propertyKey) {
+            // Method Decorator
+            applyGuards(descriptor, guards, String(propertyKey));
+            // Store guard metadata for later access (if needed)
+            Reflect.defineMetadata('guards', guards, target, propertyKey);
+        } else if (typeof target === 'function' && !propertyKey && !descriptor) {
+            // Class Decorator
+            const prototype = target.prototype;
+            // 1. Get all methods to guard
+            const methods = new Set();
+            const commandMap = meocord_app.getCommandMap(prototype) || {};
+            Object.values(commandMap).flat().forEach((cmd)=>methods.add(cmd.methodName));
+            const messageHandlers = meocord_app.getMessageHandlers(prototype) || [];
+            messageHandlers.forEach((handler)=>methods.add(handler.method));
+            const reactionHandlers = meocord_app.getReactionHandlers(prototype) || [];
+            reactionHandlers.forEach((handler)=>methods.add(handler.method));
+            for (const methodName of methods){
+                const methodDescriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+                if (methodDescriptor) {
+                    applyGuards(methodDescriptor, guards, methodName);
+                    Object.defineProperty(prototype, methodName, methodDescriptor);
+                    Reflect.defineMetadata('guards', guards, prototype, methodName);
+                }
+            }
+        }
+    };
+}
+
+/**
+ * Binds a class and its dependencies to the Inversify container in singleton scope.
+ *
+ * @param {Container} container - The Inversify container instance.
+ * @param {any} cls - The class to be bound to the container.
+ */ function bindDependencies(container, cls) {
+    if (!container.isBound(cls)) {
+        container.bind(cls).toSelf().inSingletonScope();
+        const dependencies = Reflect.getMetadata('design:paramtypes', cls) || [];
+        dependencies.forEach((dep)=>bindDependencies(container, dep));
+    }
+}
+/**
+ * Resolves dependencies for a given class by binding them to the container and returning the resolved instances.
+ *
+ * @param {Container} container - The Inversify container instance.
+ * @param {any} target - The target class whose dependencies are to be resolved.
+ * @returns {any[]} - An array of resolved instances of the target's dependencies.
+ */ function resolveDependencies(container, target) {
+    const injectables = Reflect.getMetadata('design:paramtypes', target) || [];
+    return injectables.map((dep)=>{
+        bindDependencies(container, dep);
+        return container.get(dep);
+    });
+}
+/**
+ * `@MeoCord()` decorator for initializing and setting up the MeoCord application.
+ *
+ * @param {Object} options - The decorator options.
+ * @param {ServiceIdentifier[]} options.controllers - The list of controllers to be registered.
+ * @param {ClientOptions} options.clientOptions - The Discord client options for initializing the bot.
+ * @param {ActivityOptions[]} [options.activities] - Optional activities for the bot.
+ * @param {ServiceIdentifier[]} [options.services] - Optional services to be registered.
+ *
+ * @example
+ * ```typescript
+ * @MeoCord({
+ *   controllers: [PingSlashController],
+ *   clientOptions: {
+ *     intents: [
+ *       GatewayIntentBits.Guilds,
+ *       GatewayIntentBits.GuildMembers,
+ *       GatewayIntentBits.GuildMessages,
+ *       GatewayIntentBits.GuildMessageReactions,
+ *       GatewayIntentBits.MessageContent,
+ *     ],
+ *     partials: [Partials.Message, Partials.Channel, Partials.Reaction],
+ *   },
+ *   activities: [{
+ *       name: `${sample(['Genshin', 'ZZZ'])} with Romeo`,
+ *       type: ActivityType.Playing,
+ *       url: 'https://enka.network/u/824957678/',
+ *   }],
+ *   services: [MyStandaloneService],
+ * })
+ * class MyApp {}
+ * ```
+ **/ function MeoCord(options) {
+    return (target)=>{
+        if (!Reflect.hasMetadata('inversify:injectable', target)) {
+            inversify.injectable()(target); // Make target injectable (inversify-specific)
+        }
+        const meocordConfig = theme.loadMeoCordConfig();
+        if (!meocordConfig) return;
+        const discordClient = new discord_js.Client(options.clientOptions);
+        meocord_app.mainContainer.bind(discord_js.Client).toConstantValue(discordClient);
+        [
+            ...options.controllers,
+            ...options.services || []
+        ].forEach((dep)=>{
+            bindDependencies(meocord_app.mainContainer, dep);
+        });
+        // Bind other static values to the container
+        meocord_app.mainContainer.bind(target).toConstantValue(options.clientOptions);
+        if (options.activities) {
+            meocord_app.mainContainer.bind(target).toConstantValue(options.activities);
+        }
+        if (options.services) {
+            meocord_app.mainContainer.bind(target).toConstantValue(options.services.map((s)=>meocord_app.mainContainer.get(s)));
+        }
+        const meocordApp = new meocord_app.MeoCordApp(options.controllers.map((c)=>meocord_app.mainContainer.get(c)), discordClient, meocordConfig.discordToken, options?.activities);
+        meocord_app.mainContainer.bind(meocord_app.MeoCordApp).toConstantValue(meocordApp);
+        // Bind the App class dynamically with resolved dependencies
+        meocord_app.mainContainer.bind(target).toDynamicValue(()=>{
+            const dependencies = resolveDependencies(meocord_app.mainContainer, target);
+            return new target(...dependencies);
+        }).inSingletonScope();
+        Reflect.defineMetadata('inversify:container', meocord_app.mainContainer, target);
+    };
+}
+
+exports.Command = meocord_app.Command;
+exports.Controller = meocord_app.Controller;
+exports.MessageHandler = meocord_app.MessageHandler;
+exports.ReactionHandler = meocord_app.ReactionHandler;
+exports.getCommandMap = meocord_app.getCommandMap;
+exports.getMessageHandlers = meocord_app.getMessageHandlers;
+exports.getReactionHandlers = meocord_app.getReactionHandlers;
+exports.mainContainer = meocord_app.mainContainer;
+exports.CommandBuilder = CommandBuilder;
+exports.Guard = Guard;
+exports.MeoCord = MeoCord;
+exports.Service = Service;
+exports.UseGuard = UseGuard;

package/dist/cjs/enum/index.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var CommandType = /*#__PURE__*/ function(CommandType) {
+    CommandType["SLASH"] = "SLASH";
+    CommandType["BUTTON"] = "BUTTON";
+    CommandType["CONTEXT_MENU"] = "CONTEXT_MENU";
+    CommandType["SELECT_MENU"] = "SELECT_MENU";
+    CommandType["MODAL_SUBMIT"] = "MODAL_SUBMIT";
+    return CommandType;
+}({});
+/**
+ * Enum representing actions that can be performed on a message reaction.
+ */ var ReactionHandlerAction = /*#__PURE__*/ function(ReactionHandlerAction) {
+    /** Reaction added to a message. */ ReactionHandlerAction["ADD"] = "ADD";
+    /** Reaction removed from a message. */ ReactionHandlerAction["REMOVE"] = "REMOVE";
+    return ReactionHandlerAction;
+}({});
+
+exports.CommandType = CommandType;
+exports.ReactionHandlerAction = ReactionHandlerAction;

package/dist/cjs/interface/index.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/esm/bin/generator.js

@@ -0,0 +1,92 @@
+import { Argument } from 'commander';
+import { ControllerGeneratorHelper } from './helper/controller-generator.helper.js';
+import { Logger } from '../common/logger.js';
+import '../common/theme.js';
+import { ServiceGeneratorHelper } from './helper/service-generator.helper.js';
+import { GuardGeneratorHelper } from './helper/guard-generator.helper.js';
+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)=>{
+            await this.handleGenerateComponent({
+                component: 'controller',
+                type: type,
+                name
+            });
+        });
+        generatorCommand.command('service').alias('s').addArgument(new Argument('<name>', 'Name of the service.')).description('Generate a service component').action(async (name)=>{
+            await this.handleGenerateComponent({
+                component: 'service',
+                name
+            });
+        });
+        generatorCommand.command('guard').alias('gu').addArgument(new Argument('<name>', 'Name of the guard.')).description('Generate a guard component').action(async (name)=>{
+            await this.handleGenerateComponent({
+                component: 'guard',
+                name
+            });
+        });
+        return program;
+    }
+    async handleGenerateComponent(args) {
+        const { component, name, type } = args;
+        if (!name) {
+            this.logger.error('Name is required');
+            await wait(100);
+            process.exit(1);
+        }
+        switch(component){
+            case 'controller':
+                if (!type) {
+                    this.logger.error('Type is required for controllers');
+                    await wait(100);
+                    process.exit(1);
+                }
+                await this.handleGenerateController({
+                    name,
+                    type
+                });
+                break;
+            case 'service':
+                this.serviceGeneratorHelper.generateService(name);
+                break;
+            case 'guard':
+                this.guardGeneratorHelper.generateGuard(name);
+                break;
+            default:
+                this.logger.error(`Unsupported component type: ${component}`);
+                await wait(100);
+                process.exit(1);
+        }
+    }
+    async handleGenerateController(args) {
+        try {
+            this.controllerGeneratorHelper.generateController({
+                controllerName: args.name
+            }, args.type);
+        } catch (error) {
+            this.logger.error(`Error generating controller: ${error instanceof Error ? error.message : String(error)}`);
+            await wait(100);
+            process.exit(1);
+        }
+    }
+    constructor(appName){
+        this.appName = appName;
+        this.logger = new Logger(this.appName);
+        this.controllerGeneratorHelper = new ControllerGeneratorHelper();
+        this.serviceGeneratorHelper = new ServiceGeneratorHelper(this.appName);
+        this.guardGeneratorHelper = new GuardGeneratorHelper(this.appName);
+    }
+}
+
+export { GeneratorCLI };

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

@@ -0,0 +1,105 @@
+import path from 'path';
+import { ControllerType } from '../../enum/controller.enum.js';
+import { validateAndFormatName, populateTemplate, createDirectoryIfNotExists, generateFile } from '../../util/generator-cli.util.js';
+import { fileURLToPath } from 'url';
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+class ControllerGeneratorHelper {
+    /**
+   * Generates a new controller file and an associated structure based on the provided arguments and controller type.
+   * @param args - The arguments for generating the controller, including the optional controller name.
+   * @param type - The type of the controller to generate, defined in the `ControllerType` enum.
+   * @throws Will throw an error if the controller name is invalid or if the controller type is unsupported.
+   */ 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);
+        this.generateControllerStructure(controllerDir, kebabCaseName, className, type, template);
+    }
+    /**
+   * Builds the controller template content by populating a template with variables.
+   * @param className - The name of the controller class.
+   * @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);
+        if (!templateConfig) {
+            throw new Error(`Unsupported controller type: ${type}`);
+        }
+        return populateTemplate(templateConfig.template, templateConfig.variables);
+    }
+    /**
+   * Retrieves the template configuration for a specific controller type and class name.
+   * @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) {
+        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.REACTION]: 'reaction.controller.template',
+            [ControllerType.MESSAGE]: 'message.controller.template',
+            [ControllerType.CONTEXT_MENU]: 'context-menu.controller.template',
+            [ControllerType.SLASH]: 'slash.controller.template'
+        };
+        const template = templates[type] ? path.resolve(baseDir, templates[type]) : undefined;
+        return template ? {
+            template,
+            variables: {
+                className
+            }
+        } : undefined;
+    }
+    /**
+   * Generates the controller file and its associated structure (e.g., builder files, directories).
+   * @param controllerDir - The absolute path to the controller directory.
+   * @param kebabCaseName - The kebab-case name of the controller file.
+   * @param className - The name of the controller class.
+   * @param type - The type of the controller, defined in the `ControllerType` enum.
+   * @param controllerTemplate - The populated template string for the controller file.
+   */ generateControllerStructure(controllerDir, kebabCaseName, className, type, controllerTemplate) {
+        this.generateBuilderFile(className, type, controllerDir);
+        createDirectoryIfNotExists(controllerDir);
+        const controllerFilePath = path.join(controllerDir, `${kebabCaseName}.${type}.controller.ts`);
+        generateFile(controllerFilePath, controllerTemplate);
+    }
+    /**
+   * Generates a builder file for the specified controller type and stores it in the controller directory.
+   * @param className - The name of the controller class.
+   * @param type - The type of the controller, defined in the `ControllerType` enum.
+   * @param controllerDir - The absolute path to the controller directory.
+   */ generateBuilderFile(className, type, controllerDir) {
+        const builderConfig = this.getBuilderConfig(type, className);
+        if (!builderConfig) return;
+        const builderTemplate = populateTemplate(builderConfig.template, builderConfig.variables);
+        const buildersDir = path.join(controllerDir, 'builders');
+        createDirectoryIfNotExists(buildersDir);
+        const builderFilePath = path.join(buildersDir, 'sample.builder.ts');
+        generateFile(builderFilePath, builderTemplate);
+    }
+    /**
+   * Retrieves the configuration for generating a builder file based on the controller type and class name.
+   * @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 builder template path and variables, or `undefined` if not found.
+   */ getBuilderConfig(type, className) {
+        const baseDir = path.resolve(__dirname$1, '..', 'builder-template', 'builder');
+        const templates = {
+            [ControllerType.CONTEXT_MENU]: 'context-menu.builder.template',
+            [ControllerType.SLASH]: 'slash.builder.template'
+        };
+        const template = templates[type] ? path.resolve(baseDir, templates[type]) : undefined;
+        return template ? {
+            template,
+            variables: {
+                className
+            }
+        } : undefined;
+    }
+}
+
+export { ControllerGeneratorHelper };

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

@@ -0,0 +1,33 @@
+import path from 'path';
+import { Logger } from '../../common/logger.js';
+import '../../common/theme.js';
+import { validateAndFormatName, buildTemplate, createDirectoryIfNotExists, generateFile } from '../../util/generator-cli.util.js';
+
+class GuardGeneratorHelper {
+    /**
+   * Generates a guard file based on the provided guard name.
+   * Validates and formats the guard name, creates the necessary directories,
+   * and generates the guard file using a predefined template.
+   *
+   * @param guardName - The name of the guard to generate.
+   *                      It can include slashes for nested paths.
+   * @throws Exits the process if the guard name is not provided or invalid.
+   */ generateGuard(guardName) {
+        if (!guardName) {
+            this.logger.error('Guard name is required.');
+            process.exit(1);
+        }
+        const { parts, kebabCaseName, className } = validateAndFormatName(guardName);
+        const guardDir = path.join(process.cwd(), 'src', 'guards', ...parts);
+        const guardFile = path.join(guardDir, `${kebabCaseName}.guard.ts`);
+        const guardTemplate = buildTemplate(className, 'guard.template');
+        createDirectoryIfNotExists(guardDir);
+        generateFile(guardFile, guardTemplate);
+    }
+    constructor(appName){
+        this.appName = appName;
+        this.logger = new Logger(this.appName);
+    }
+}
+
+export { GuardGeneratorHelper };