meocord 1.2.1 → 1.2.2

package/dist/esm/core/meocord.app.js

@@ -0,0 +1,267 @@
+import { SlashCommandBuilder, MessageFlagsBitField } from 'discord.js';
+import { Logger } from '../common/logger.js';
+import '../common/theme.js';
+import { getCommandMap, getMessageHandlers, getReactionHandlers } from '../decorator/controller.decorator.js';
+import { mainContainer } from '../decorator/container.js';
+import { sample } from 'lodash-es';
+import { createErrorEmbed } from '../util/embed.util.js';
+import { ReactionHandlerAction, CommandType } from '../enum/controller.enum.js';
+
+class MeoCordApp {
+    async start() {
+        try {
+            this.logger.log('Starting bot...');
+            this.bot.on('clientReady', async ()=>{
+                this.activityInterval = setInterval(()=>{
+                    this.bot.user?.setActivity(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: ReactionHandlerAction.ADD
+                });
+            });
+            this.bot.on('messageReactionRemove', async (reaction, user)=>{
+                await this.handleReaction(reaction, {
+                    user,
+                    action: 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 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 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 === CommandType.SLASH && interaction.isChatInputCommand() || type === CommandType.BUTTON && interaction.isButton() || type === CommandType.SELECT_MENU && interaction.isStringSelectMenu() || type === CommandType.CONTEXT_MENU && interaction.isUserContextMenuCommand() || type === CommandType.CONTEXT_MENU && interaction.isMessageContextMenuCommand() || type === CommandType.MODAL_SUBMIT && interaction.isModalSubmit()) {
+                        this.logger.log('[INTERACTION]', `[${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, 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: 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: 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 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());
+    }
+}
+
+export { MeoCordApp };

package/dist/esm/decorator/app.decorator.js

@@ -0,0 +1,99 @@
+import 'reflect-metadata';
+import { mainContainer } from './container.js';
+import { injectable } from 'inversify';
+import { Client } from 'discord.js';
+import { MeoCordApp } from '../core/meocord.app.js';
+import { loadMeoCordConfig } from '../util/meocord-config-loader.util.js';
+
+/**
+ * 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)) {
+            injectable()(target); // Make target injectable (inversify-specific)
+        }
+        const meocordConfig = loadMeoCordConfig();
+        if (!meocordConfig) return;
+        const discordClient = new Client(options.clientOptions);
+        mainContainer.bind(Client).toConstantValue(discordClient);
+        [
+            ...options.controllers,
+            ...options.services || []
+        ].forEach((dep)=>{
+            bindDependencies(mainContainer, dep);
+        });
+        // Bind other static values to the container
+        mainContainer.bind(target).toConstantValue(options.clientOptions);
+        if (options.activities) {
+            mainContainer.bind(target).toConstantValue(options.activities);
+        }
+        if (options.services) {
+            mainContainer.bind(target).toConstantValue(options.services.map((s)=>mainContainer.get(s)));
+        }
+        const meocordApp = new MeoCordApp(options.controllers.map((c)=>mainContainer.get(c)), discordClient, meocordConfig.discordToken, options?.activities);
+        mainContainer.bind(MeoCordApp).toConstantValue(meocordApp);
+        // Bind the App class dynamically with resolved dependencies
+        mainContainer.bind(target).toDynamicValue(()=>{
+            const dependencies = resolveDependencies(mainContainer, target);
+            return new target(...dependencies);
+        }).inSingletonScope();
+        Reflect.defineMetadata('inversify:container', mainContainer, target);
+    };
+}
+
+export { MeoCord };

package/dist/esm/decorator/command-builder.decorator.js

@@ -0,0 +1,32 @@
+import 'reflect-metadata';
+import { injectable } from 'inversify';
+
+/**
+ * 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)) {
+            injectable()(target);
+        }
+        // Define the command type metadata for the target class
+        Reflect.defineMetadata('commandType', commandType, target);
+    };
+}
+
+export { CommandBuilder };

package/dist/esm/decorator/container.js

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { Container } from 'inversify';
+
+const mainContainer = new Container();
+
+export { mainContainer };

package/dist/esm/decorator/controller.decorator.js

@@ -0,0 +1,218 @@
+import 'reflect-metadata';
+import { injectable } from 'inversify';
+import { mainContainer } from './container.js';
+import { ButtonInteraction, StringSelectMenuInteraction, ChatInputCommandInteraction, ContextMenuCommandInteraction, ModalSubmitInteraction } from 'discord.js';
+import { CommandType } from '../enum/controller.enum.js';
+
+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 === CommandType.BUTTON && interaction instanceof ButtonInteraction || commandType === CommandType.SELECT_MENU && interaction instanceof StringSelectMenuInteraction || commandType === CommandType.SLASH && interaction instanceof ChatInputCommandInteraction || commandType === CommandType.CONTEXT_MENU && interaction instanceof ContextMenuCommandInteraction || commandType === CommandType.MODAL_SUBMIT && interaction instanceof 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 CommandType)) {
+                throw new Error(`Metadata for 'commandType' is missing on builder ${builderOrType.name}`);
+            }
+        } else {
+            commandType = builderOrType;
+        }
+        if (commandType !== CommandType.SLASH && commandType !== 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)) {
+            injectable()(target);
+        }
+        const injectables = Reflect.getMetadata('design:paramtypes', target) || [];
+        injectables.map((dep)=>{
+            if (!mainContainer.isBound(dep)) {
+                if (!Reflect.hasMetadata('inversify:injectable', dep)) {
+                    injectable()(dep);
+                }
+                mainContainer.bind(dep).toSelf().inSingletonScope();
+            }
+        });
+        Reflect.defineMetadata('inversify:container', mainContainer, target);
+    };
+}
+
+export { Command, Controller, MessageHandler, ReactionHandler, getCommandMap, getMessageHandlers, getReactionHandlers };