meocord 1.2.0 → 1.2.2-0

package/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.2-0] - 2026-04-09
+
+### Changed
+
+- **Breaking:** Migrate build system from Babel to Rollup. Output structure changed from `dist/` to `dist/{esm,cjs,types}/`. Package exports updated accordingly. ([33d77b4](https://github.com/l7aromeo/meocord/commit/33d77b4))
+- Replace Babel with Rollup for faster ESM, CJS, and declaration builds. ([33d77b4](https://github.com/l7aromeo/meocord/commit/33d77b4))
+- Move `discord.js` from dependencies to peer dependencies only, preventing duplicate package installs in consumer projects. ([33d77b4](https://github.com/l7aromeo/meocord/commit/33d77b4))
+- Replace webpack-based TypeScript config compilation with jiti runtime loader for faster startup and no temp file generation. ([923e01f](https://github.com/l7aromeo/meocord/commit/923e01f))
+
+### Fixed
+
+- Resolve webpack config path in CLI after dist structure change. ([b80f770](https://github.com/l7aromeo/meocord/commit/b80f770))
+- Resolve circular dependency between `core/meocord.app.ts` and `decorator/app.decorator.ts`. ([ac01d34](https://github.com/l7aromeo/meocord/commit/ac01d34))
+- Extract context validation in `@UseGuard` to a type predicate function to eliminate redundant `instanceof` check warnings. ([fa3b18c](https://github.com/l7aromeo/meocord/commit/fa3b18c))
+
+## [1.2.1] - 2026-03-18
+
+### Fixed
+
+- Fix graceful shutdown requiring double Ctrl+C to fully exit by properly handling SIGINT across parent and child processes. ([293377b](https://github.com/l7aromeo/meocord/commit/293377b))
+- Clear activity `setInterval` on shutdown to prevent it from keeping the process alive. ([293377b](https://github.com/l7aromeo/meocord/commit/293377b))
+- Remove unnecessary `wait()` delays in shutdown path for faster exit. ([293377b](https://github.com/l7aromeo/meocord/commit/293377b))
+- Add force-exit on second Ctrl+C at all process levels to prevent hanging when `bot.destroy()` stalls. ([293377b](https://github.com/l7aromeo/meocord/commit/293377b))
+- Propagate child process exit code to parent instead of always exiting with 0. ([293377b](https://github.com/l7aromeo/meocord/commit/293377b))
+
 ## [1.2.0] - 2026-03-11
 
 ### Added

package/dist/cjs/_shared/meocord.app-CHjdCAA_.cjs

@@ -0,0 +1,496 @@
+'use strict';
+
+var discord_js = require('discord.js');
+var theme = require('./theme-BdtbtMZX.cjs');
+require('reflect-metadata');
+var inversify = require('inversify');
+var enum_index = require('../enum/index.cjs');
+var lodashEs = require('lodash-es');
+
+const mainContainer = new inversify.Container();
+
+const COMMAND_METADATA_KEY = Symbol('commands');
+const MESSAGE_HANDLER_METADATA_KEY = Symbol('message_handlers');
+const REACTION_HANDLER_METADATA_KEY = Symbol('reaction_handlers');
+/**
+ * Decorator to register message handlers in the controller.
+ *
+ * @param keyword - An optional keyword to filter messages this handler should respond to.
+ *
+ * @example
+ * ```typescript
+ * @MessageHandler('hello')
+ * async handleHelloMessage(message: Message) {
+ *   await message.reply('Hello! How can I help you?');
+ * }
+ *
+ * @MessageHandler()
+ * async handleAnyMessage(message: Message) {
+ *   console.log(`Received a message: ${message.content}`);
+ * }
+ * ```
+ */ function MessageHandler(keyword) {
+    return function(target, propertyKey, _descriptor) {
+        const handlers = Reflect.getMetadata(MESSAGE_HANDLER_METADATA_KEY, target) || [];
+        handlers.push({
+            keyword,
+            method: propertyKey.toString()
+        });
+        Reflect.defineMetadata(MESSAGE_HANDLER_METADATA_KEY, handlers, target);
+    };
+}
+/**
+ * Decorator to register reaction handlers in the controller.
+ *
+ * @param emoji - Optional emoji name to filter reactions this handler should respond to.
+ *
+ * @example
+ * ```typescript
+ * @ReactionHandler('👍')
+ * async handleThumbsUpReaction(reaction: MessageReaction, { user }: ReactionHandlerOptions) {
+ *   console.log(`User ${user.username} reacted with 👍`);
+ * }
+ *
+ * @ReactionHandler()
+ * async handleAnyReaction(reaction: MessageReaction, { user }: ReactionHandlerOptions) {
+ *   console.log(`User ${user.username} reacted with ${reaction.emoji.name}`);
+ * }
+ * ```
+ */ function ReactionHandler(emoji) {
+    return function(target, propertyKey, _descriptor) {
+        const handlers = Reflect.getMetadata(REACTION_HANDLER_METADATA_KEY, target) || [];
+        handlers.push({
+            emoji,
+            method: propertyKey.toString()
+        });
+        Reflect.defineMetadata(REACTION_HANDLER_METADATA_KEY, handlers, target);
+    };
+}
+/**
+ * Retrieves reaction handlers metadata from a given controller.
+ *
+ * @param controller - The controller class instance.
+ * @returns An array of reaction handler metadata objects.
+ */ function getReactionHandlers(controller) {
+    return Reflect.getMetadata(REACTION_HANDLER_METADATA_KEY, controller) || [];
+}
+/**
+ * Retrieves message handlers metadata from a given controller.
+ *
+ * @param controller - The controller class instance.
+ * @returns An array of message handler method names.
+ */ function getMessageHandlers(controller) {
+    return Reflect.getMetadata(MESSAGE_HANDLER_METADATA_KEY, controller) || [];
+}
+/**
+ * Helper function to create regex and parameter mappings from a pattern string.
+ *
+ * @param pattern - The pattern string to parse.
+ * @returns An object containing the generated regex and parameter names.
+ */ function createRegexFromPattern(pattern) {
+    const params = [];
+    // Escape special characters except for {} and -
+    const escapedPattern = pattern.replace(/[/\\^$*+?.()|[\]]/g, '\\$&') // Removed hyphen `-` from this list
+    ;
+    // Replace placeholders with named capturing groups
+    const regexPattern = escapedPattern.replace(/\{(\w+)}/g, (_, param)=>{
+        if (!/^\w+$/.test(param)) {
+            throw new Error(`Invalid parameter name: ${param}. Parameter names must be alphanumeric.`);
+        }
+        params.push(param);
+        return `(?<${param}>[a-zA-Z0-9]+)`;
+    });
+    // Construct the final regex
+    const regex = new RegExp(`^${regexPattern}$`);
+    return {
+        regex,
+        params
+    };
+}
+/**
+ * Decorator to register command methods in a controller.
+ *
+ * @param commandName - The name or pattern of the command.
+ * @param builderOrType - A command builder class or a command type from `CommandType`.
+ *
+ * @example
+ * ```typescript
+ * @Command('help', CommandType.SLASH)
+ * public async handleHelp(interaction: ChatInputCommandInteraction) {
+ *   await interaction.reply('This is the help command!')
+ * }
+ *
+ * @Command('stats-{id}', CommandType.BUTTON)
+ * public async handleStats(message: ButtonInteraction, { id }) {
+ *   await message.reply(`Fetching stats for ID: ${id}`);
+ * }
+ * ```
+ */ function Command(commandName, builderOrType) {
+    return function(target, propertyKey, _descriptor) {
+        const originalMethod = _descriptor.value;
+        if (!originalMethod) {
+            throw new Error(`Missing implementation for method ${propertyKey}`);
+        }
+        // Wrap original method for interaction type validation
+        _descriptor.value = function(interaction, params) {
+            const expectedInteraction = commandType === enum_index.CommandType.BUTTON && interaction instanceof discord_js.ButtonInteraction || commandType === enum_index.CommandType.SELECT_MENU && interaction instanceof discord_js.StringSelectMenuInteraction || commandType === enum_index.CommandType.SLASH && interaction instanceof discord_js.ChatInputCommandInteraction || commandType === enum_index.CommandType.CONTEXT_MENU && interaction instanceof discord_js.ContextMenuCommandInteraction || commandType === enum_index.CommandType.MODAL_SUBMIT && interaction instanceof discord_js.ModalSubmitInteraction;
+            if (!expectedInteraction) {
+                throw new Error(`Invalid interaction type passed to @Command for method: ${propertyKey}`);
+            }
+            return originalMethod.apply(this, [
+                interaction,
+                params
+            ]);
+        };
+        // Retrieve existing metadata or initialize it
+        const commands = Reflect.getMetadata(COMMAND_METADATA_KEY, target) || {};
+        let builderInstance;
+        let commandType;
+        let regex;
+        let dynamicParams = [];
+        // Determine command type and builder
+        if (typeof builderOrType === 'function') {
+            const builderObj = new builderOrType();
+            builderInstance = builderObj.build(commandName);
+            commandType = Reflect.getMetadata('commandType', builderOrType);
+            if (!(commandType in enum_index.CommandType)) {
+                throw new Error(`Metadata for 'commandType' is missing on builder ${builderOrType.name}`);
+            }
+        } else {
+            commandType = builderOrType;
+        }
+        if (commandType !== enum_index.CommandType.SLASH && commandType !== enum_index.CommandType.CONTEXT_MENU) {
+            const { regex: generatedRegex, params } = createRegexFromPattern(commandName);
+            regex = generatedRegex;
+            dynamicParams = params;
+        }
+        // Ensure commandName supports multiple entries
+        if (!commands[commandName]) {
+            commands[commandName] = [];
+        }
+        commands[commandName].push({
+            methodName: propertyKey,
+            builder: builderInstance,
+            type: commandType,
+            regex,
+            dynamicParams
+        });
+        Reflect.defineMetadata(COMMAND_METADATA_KEY, commands, target);
+    };
+}
+/**
+ * Retrieves the command map for a given controller.
+ *
+ * @param controller - The controller class instance.
+ * @returns A record containing command metadata indexed by command names.
+ */ function getCommandMap(controller) {
+    return Reflect.getMetadata(COMMAND_METADATA_KEY, controller);
+}
+/**
+ * Decorator to mark a class as a controller that can later be registered to the App class `(app.ts)` using the `@MeoCord` decorator.
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class PingSlashController {
+ *   constructor(private pingService: PingService) {}
+ *
+ *   @Command('ping', PingCommandBuilder)
+ *   async ping(interaction: ChatInputCommandInteraction) {
+ *     const response = await this.pingService.handlePing()
+ *     await interaction.reply(response)
+ *   }
+ * }
+ * ```
+ */ function Controller() {
+    return function(target) {
+        if (!Reflect.hasMetadata('inversify:injectable', target)) {
+            inversify.injectable()(target);
+        }
+        const injectables = Reflect.getMetadata('design:paramtypes', target) || [];
+        injectables.map((dep)=>{
+            if (!mainContainer.isBound(dep)) {
+                if (!Reflect.hasMetadata('inversify:injectable', dep)) {
+                    inversify.injectable()(dep);
+                }
+                mainContainer.bind(dep).toSelf().inSingletonScope();
+            }
+        });
+        Reflect.defineMetadata('inversify:container', mainContainer, target);
+    };
+}
+
+const createErrorEmbed = (description)=>{
+    const embed = new discord_js.EmbedBuilder();
+    embed.setColor(theme.Theme.errorColor);
+    embed.setTitle('Oops!');
+    embed.setDescription(description);
+    return embed;
+};
+
+class MeoCordApp {
+    async start() {
+        try {
+            this.logger.log('Starting bot...');
+            this.bot.on('clientReady', async ()=>{
+                this.activityInterval = setInterval(()=>{
+                    this.bot.user?.setActivity(lodashEs.sample(this.activities));
+                }, 10000);
+                await this.registerCommands();
+            });
+            this.bot.on('interactionCreate', async (interaction)=>{
+                await this.handleInteraction(interaction);
+            });
+            this.bot.on('messageCreate', async (message)=>{
+                await this.handleMessage(message);
+            });
+            this.bot.on('messageReactionAdd', async (reaction, user)=>{
+                await this.handleReaction(reaction, {
+                    user,
+                    action: enum_index.ReactionHandlerAction.ADD
+                });
+            });
+            this.bot.on('messageReactionRemove', async (reaction, user)=>{
+                await this.handleReaction(reaction, {
+                    user,
+                    action: enum_index.ReactionHandlerAction.REMOVE
+                });
+            });
+            await this.bot.login(this.discordToken);
+            this.logger.log('Bot is online!');
+        } catch (error) {
+            this.logger.error('Error during bot startup:', error);
+        }
+    }
+    async registerCommands() {
+        const builders = [];
+        for (const controller of this.controllers){
+            const commandMap = getCommandMap(controller);
+            for(const commandName in commandMap){
+                const commandMetadataArray = commandMap[commandName];
+                if (!Array.isArray(commandMetadataArray)) continue;
+                for (const { builder, type } of commandMetadataArray){
+                    if (type in enum_index.CommandType && builder) {
+                        builders.push(builder);
+                    }
+                }
+            }
+        }
+        try {
+            if (this.bot.application) {
+                await this.bot.application.commands.set(builders);
+                this.logger.log(`Registered ${builders.length} bot commands:`, builders.map((builder)=>{
+                    const json = typeof builder.toJSON === 'function' ? builder.toJSON() : builder;
+                    const typeName = json?.type === 1 ? 'SlashCommand' : json?.type === 2 ? 'UserContextMenu' : json?.type === 3 ? 'MessageContextMenu' : builder instanceof discord_js.SlashCommandBuilder ? 'SlashCommand' : 'Command';
+                    const subCommands = Array.isArray(json?.options) && json.options.length ? json.options.map((opt)=>({
+                            name: opt.name,
+                            options: opt.options.map((opt)=>opt.name)
+                        })) : undefined;
+                    const name = json?.name || builder.name;
+                    return subCommands ? {
+                        type: typeName,
+                        name,
+                        subCommands
+                    } : {
+                        type: typeName,
+                        name
+                    };
+                }));
+            }
+        } catch (error) {
+            this.logger.error('Error during command registration:', error);
+        }
+    }
+    async handleInteraction(interaction) {
+        for (const controller of this.controllers){
+            let controllerInstance = this.controllerInstancesCache.get(controller);
+            if (!controllerInstance) {
+                controllerInstance = mainContainer.get(controller.constructor);
+                this.controllerInstancesCache.set(controller, controllerInstance);
+            }
+            const commandMap = getCommandMap(controllerInstance);
+            if (!commandMap) continue;
+            let commandMetadataArray = undefined;
+            let commandIdentifier = undefined;
+            if (interaction.isChatInputCommand() || interaction.isContextMenuCommand()) {
+                commandIdentifier = interaction.commandName;
+                commandMetadataArray = commandMap[commandIdentifier];
+            } else if (interaction.isButton() || interaction.isStringSelectMenu() || interaction.isModalSubmit()) {
+                commandIdentifier = interaction.customId;
+                const foundEntry = Object.entries(commandMap).find(([commandName, metaArray])=>{
+                    if (!Array.isArray(metaArray)) return false;
+                    return metaArray.some((meta)=>{
+                        if (!meta.regex || !commandIdentifier) return false;
+                        const match = meta.regex.exec(commandIdentifier);
+                        if (match?.groups) {
+                            interaction.dynamicParams = match.groups;
+                            return true;
+                        }
+                        return commandIdentifier === commandName;
+                    });
+                });
+                if (foundEntry) {
+                    commandMetadataArray = foundEntry[1];
+                }
+            }
+            if (commandMetadataArray && commandMetadataArray.length > 0) {
+                const commandMetadata = commandMetadataArray[0];
+                const { methodName, type } = commandMetadata;
+                try {
+                    if (type === enum_index.CommandType.SLASH && interaction.isChatInputCommand() || type === enum_index.CommandType.BUTTON && interaction.isButton() || type === enum_index.CommandType.SELECT_MENU && interaction.isStringSelectMenu() || type === enum_index.CommandType.CONTEXT_MENU && interaction.isUserContextMenuCommand() || type === enum_index.CommandType.CONTEXT_MENU && interaction.isMessageContextMenuCommand() || type === enum_index.CommandType.MODAL_SUBMIT && interaction.isModalSubmit()) {
+                        this.logger.log('[INTERACTION]', `[${enum_index.CommandType[type]}]`, `[${methodName}]`);
+                        let dynamicParams = {};
+                        if (interaction.isChatInputCommand() && interaction.options) {
+                            dynamicParams = interaction.options.data.reduce((acc, opt)=>{
+                                acc[opt.name] = opt.value;
+                                return acc;
+                            }, {});
+                        } else if (interaction.isButton() || interaction.isStringSelectMenu() || interaction.isModalSubmit()) {
+                            dynamicParams = interaction.dynamicParams || {};
+                        }
+                        await controllerInstance[methodName](interaction, dynamicParams);
+                        return;
+                    } else {
+                        this.logger.debug(type, methodName, enum_index.CommandType.BUTTON, interaction.isButton());
+                        this.logger.warn(`Interaction type mismatch for command "${commandIdentifier}". Interaction type: ${interaction.type}.`);
+                    }
+                } catch (error) {
+                    this.logger.error(`Error executing command "${commandIdentifier}":`, error);
+                    if (interaction.isRepliable()) {
+                        const embed = createErrorEmbed('An error occurred while executing the command.');
+                        await interaction.reply({
+                            embeds: [
+                                embed
+                            ],
+                            flags: discord_js.MessageFlagsBitField.Flags.Ephemeral
+                        });
+                    }
+                }
+                return;
+            }
+        }
+        // If no matching command is found
+        if (interaction.isRepliable()) {
+            const embed = createErrorEmbed('Command not found!');
+            await interaction.reply({
+                embeds: [
+                    embed
+                ],
+                flags: discord_js.MessageFlagsBitField.Flags.Ephemeral
+            });
+        }
+    }
+    async handleMessage(message) {
+        if (message.author.bot || !message.content?.trim()) return;
+        const messageContent = message.content.trim();
+        const relevantControllers = this.controllers.filter((controller)=>{
+            const messageHandlers = getMessageHandlers(controller);
+            return messageHandlers.some((handler)=>!handler.keyword || handler.keyword === messageContent);
+        });
+        for (const controller of relevantControllers){
+            let controllerInstance = this.controllerInstancesCache.get(controller.constructor);
+            if (!controllerInstance) {
+                const container = Reflect.getMetadata('inversify:container', controller.constructor);
+                controllerInstance = container.get(controller.constructor, {
+                    autobind: true
+                });
+                this.controllerInstancesCache.set(controller.constructor, controllerInstance);
+            }
+            let messageHandlers = getMessageHandlers(controller);
+            messageHandlers = messageHandlers.sort((a, b)=>{
+                if (a.keyword && !b.keyword) return -1;
+                if (!a.keyword && b.keyword) return 1;
+                return 0;
+            });
+            for (const handler of messageHandlers){
+                const { keyword, method } = handler;
+                if (!keyword || keyword === messageContent) {
+                    try {
+                        await controllerInstance[method](message);
+                    } catch (error) {
+                        this.logger.error(`Error handling message "${messageContent}" for method "${method}":`, error);
+                    }
+                }
+            }
+        }
+    }
+    async handleReaction(reaction, { user, action }) {
+        await reaction.message.fetch();
+        const relevantControllers = this.controllers.filter((controller)=>{
+            const reactionHandlers = getReactionHandlers(controller);
+            return reactionHandlers.some((handler)=>!handler.emoji || handler.emoji === reaction.emoji.name);
+        });
+        for (const controller of relevantControllers){
+            let controllerInstance = this.controllerInstancesCache.get(controller.constructor);
+            if (!controllerInstance) {
+                const container = Reflect.getMetadata('inversify:container', controller.constructor);
+                controllerInstance = container.get(controller.constructor, {
+                    autobind: true
+                });
+                this.controllerInstancesCache.set(controller.constructor, controllerInstance);
+            }
+            let reactionHandlers = getReactionHandlers(controller);
+            reactionHandlers = reactionHandlers.sort((a, b)=>{
+                if (a.emoji && !b.emoji) return -1;
+                if (!a.emoji && b.emoji) return 1;
+                return 0;
+            });
+            for (const handler of reactionHandlers){
+                const { emoji, method } = handler;
+                if (!emoji || emoji === reaction.emoji.name) {
+                    try {
+                        await controllerInstance[method](reaction, {
+                            user,
+                            action
+                        });
+                    } catch (error) {
+                        this.logger.error(`Error handling reaction "${reaction.emoji.name}" for method "${method}":`, error);
+                    }
+                }
+            }
+        }
+    }
+    async gracefulShutdown() {
+        if (this.isShuttingDown) {
+            // Second signal received while shutting down — force exit immediately
+            process.exit(1);
+        }
+        if (this.bot) {
+            try {
+                this.isShuttingDown = true;
+                this.logger.log('Shutting down bot...');
+                if (this.activityInterval) clearInterval(this.activityInterval);
+                this.bot.removeAllListeners();
+                await this.bot.destroy();
+                this.logger.log('Bot has shut down');
+                process.exit(0);
+            } catch (error) {
+                this.logger.error('Error during shutdown:', error);
+                process.exit(1);
+            }
+        }
+    }
+    constructor(controllers, discordClient, discordToken, activities){
+        this.controllers = controllers;
+        this.discordClient = discordClient;
+        this.discordToken = discordToken;
+        this.activities = activities;
+        this.logger = new theme.Logger(MeoCordApp.name);
+        this.isShuttingDown = false;
+        this.activityInterval = null;
+        this.controllerInstancesCache = new Map();
+        this.bot = this.discordClient;
+        process.on('SIGINT', ()=>this.gracefulShutdown());
+        process.on('SIGTERM', ()=>this.gracefulShutdown());
+    }
+}
+
+exports.Command = Command;
+exports.Controller = Controller;
+exports.MeoCordApp = MeoCordApp;
+exports.MessageHandler = MessageHandler;
+exports.ReactionHandler = ReactionHandler;
+exports.getCommandMap = getCommandMap;
+exports.getMessageHandlers = getMessageHandlers;
+exports.getReactionHandlers = getReactionHandlers;
+exports.mainContainer = mainContainer;