zumito-framework 1.2.16 → 1.2.18

package/dist/services/CommandParser.js

@@ -36,4 +36,36 @@ export class CommandParser {
         });
         return paramArray;
     }
+    static async parseFromSplitedString(args, argDefinitions, guild) {
+        const parsedArgs = new Map();
+        const errors = [];
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            const type = argDefinitions[i]?.type;
+            if (type) {
+                if (type == 'member' || type == 'user') {
+                    const member = await guild.members.cache.get(arg.replace(/[<@!>]/g, ''));
+                    if (member) {
+                        if (type == 'user') {
+                            parsedArgs.set(argDefinitions[i].name, member.user);
+                        }
+                        else {
+                            parsedArgs.set(argDefinitions[i].name, member);
+                        }
+                    }
+                    else {
+                        errors.push('Invalid user.');
+                    }
+                }
+                else if (type == 'string') {
+                    parsedArgs.set(argDefinitions[i]?.name || i.toString(), arg);
+                }
+            }
+        }
+        return {
+            validated: errors.length == 0,
+            errors,
+            parsedArgs,
+        };
+    }
 }

package/dist/services/ErrorHandler.d.ts

@@ -12,8 +12,9 @@ declare type CommandErrorOptions = BaseErrorOptions & {
 export declare class ErrorHandler {
     framework: ZumitoFramework;
     constructor(framework: ZumitoFramework);
-    handleError(error: Error, options: BaseErrorOptions | CommandErrorOptions): void;
+    handleError(error: any, options: BaseErrorOptions | CommandErrorOptions): void;
     handleCommandError(error: Error, options: CommandErrorOptions): void;
+    handleShapeShiftErrors(error: any): void;
     printErrorStack(error: Error): void;
 }
 export {};

package/dist/services/ErrorHandler.js

@@ -1,6 +1,7 @@
 import ErrorStackParser from "error-stack-parser";
 import { ErrorType } from "../definitions/ErrorType";
 import chalk from "chalk";
+import sf from 'source-fragment';
 export class ErrorHandler {
     framework;
     constructor(framework) {
@@ -10,8 +11,20 @@ export class ErrorHandler {
         if (options?.type == ErrorType.CommandInstance || options?.type == ErrorType.CommandLoad || options?.type == ErrorType.CommandRun) {
             this.handleCommandError(error, options);
         }
+        else if (error.constructor.name == 'CombinedError') {
+            this.handleShapeShiftErrors(error);
+        }
+        else if (error.constructor?.name == "ExpectedValidationError") {
+            console.error(`Validation error: Expected ${error.expected}, but received ${error.given}.`);
+            console.line('');
+        }
+        else if (error.constructor.name == "ValidationError") {
+            console.error(`Validation error: ${error.validator} received invalid input: ${error.given}`);
+            console.line('');
+        }
         else {
             console.error(error.toString());
+            console.line('');
         }
         this.printErrorStack(error);
         if (options.exit)
@@ -20,7 +33,7 @@ export class ErrorHandler {
     handleCommandError(error, options) {
         switch (options.type) {
             case ErrorType.CommandInstance:
-                console.group(`[❌] Error instanciating command ${options.command.name}`);
+                console.group(`[❌] Error instanciating command ${options?.command?.name}`);
                 break;
             case ErrorType.CommandLoad:
                 console.group(`[❌] Error loading command ${options.command.name}`);
@@ -29,21 +42,70 @@ export class ErrorHandler {
                 console.group(`[❌] Error running command ${options.command.name}`);
                 break;
         }
-        console.line(error.toString());
-        console.groupEnd();
+        if (error.constructor.name == 'CombinedError') {
+            console.groupEnd();
+            this.handleShapeShiftErrors(error);
+        }
+        else {
+            console.line(chalk.red('Error:'));
+            console.line(error.toString());
+            console.line('');
+            console.groupEnd();
+        }
+    }
+    handleShapeShiftErrors(error) {
+        if (error.constructor.name == 'CombinedError') {
+            error.errors.forEach(err => {
+                this.handleError(err, {
+                    type: ErrorType.Other
+                });
+            });
+        }
     }
     printErrorStack(error) {
         const stackParsedError = ErrorStackParser.parse(error);
         let functionColor = 'blue';
-        for (let stack of stackParsedError) {
-            const filePath = stack.getFileName();
-            let functionName = stack.getFunctionName();
+        const lines = [];
+        let codeFragment;
+        let lastStack;
+        for (const stack of stackParsedError) {
+            const filePath = stack.getFileName().replace(process.cwd(), '.').replace('file://', '');
+            const functionName = stack.getFunctionName();
             if (functionName == 'CommandManager.loadCommandFile') {
                 functionColor = 'yellow';
             }
-            console.line(`    at ${chalk.gray(filePath)}:${stack.getLineNumber()}:${stack.getColumnNumber()} ${chalk[functionColor](functionName)}`);
+            lines.push(`    at ${chalk.gray(filePath)}:${stack.getLineNumber()}:${stack.getColumnNumber()} ${chalk[functionColor](functionName)}`);
             if (functionName == 'CommandManager.loadCommandFile' && !this.framework.settings.debug)
                 break;
+            if (!codeFragment && functionName.includes('.execute')) {
+                let columnEnd = -1;
+                if (lastStack) {
+                    if (lastStack.getFunctionName().contains('.')) {
+                        columnEnd = lastStack.getFunctionName().split('.').at(-1).length;
+                    }
+                    else {
+                        columnEnd = lastStack.getFunctionName().length;
+                    }
+                }
+                codeFragment = {
+                    path: `${filePath}:${stack.getLineNumber()}:${stack.getColumnNumber()}`,
+                    code: sf(`${filePath}:${stack.getLineNumber()}:${stack.getColumnNumber()}:${stack.getLineNumber()}:${stack.getColumnNumber() + columnEnd}`, {
+                        format: 'tty',
+                        linesBefore: 2,
+                        linesAfter: 2,
+                    })
+                };
+            }
+            lastStack = stack;
+        }
+        // Log code fragment
+        if (codeFragment) {
+            console.line(chalk.blue('File: ') + `${codeFragment.path}`);
+            console.line(codeFragment.code);
+            console.line('');
         }
+        // Log stack
+        console.line(chalk.blue('StackTrace:'));
+        lines.forEach(line => console.line(line));
     }
 }

package/dist/services/InteractionHandler.d.ts

@@ -0,0 +1,21 @@
+import { ButtonInteraction, Client, CommandInteraction, Interaction, ModalSubmitInteraction, StringSelectMenuInteraction } from "discord.js";
+import { CommandManager } from "./CommandManager";
+import { GuildDataGetter } from "./GuildDataGetter";
+import { TranslationManager } from "./TranslationManager";
+import { EventManager } from "./EventManager";
+import { InteractionHandlerSettings } from "@definitions/settings/InteractionHandlerSettings";
+import { ErrorHandler } from "./ErrorHandler";
+export declare class InteractionHandler {
+    protected commandManager: CommandManager;
+    protected guildDataGetter: GuildDataGetter;
+    protected client: Client;
+    protected translationManager: TranslationManager;
+    protected eventManager: EventManager;
+    protected errorHandler: ErrorHandler;
+    constructor();
+    handleInteraction(interaction: Interaction, params?: InteractionHandlerSettings): Promise<void>;
+    handleCommandInteraction(interaction: CommandInteraction, guildSettings?: any): Promise<void>;
+    handleButtonInteraction(interaction: ButtonInteraction, guildSettings?: any): Promise<void>;
+    handleSelectMenu(interaction: StringSelectMenuInteraction, guildSettings?: any): Promise<void>;
+    handleModalInteraction(interaction: ModalSubmitInteraction, guildSettings?: any): Promise<void>;
+}

package/dist/services/InteractionHandler.js

@@ -0,0 +1,206 @@
+import { Client } from "discord.js";
+import { CommandManager } from "./CommandManager";
+import { GuildDataGetter } from "./GuildDataGetter";
+import { ServiceContainer } from "./ServiceContainer";
+import { CommandType } from "../definitions/commands/CommandType";
+import { ZumitoFramework } from "../ZumitoFramework";
+import { TranslationManager } from "./TranslationManager";
+import { EventManager } from "./EventManager";
+import { ErrorHandler } from "./ErrorHandler";
+import { ErrorType } from "../definitions/ErrorType";
+export class InteractionHandler {
+    commandManager;
+    guildDataGetter;
+    client;
+    translationManager;
+    eventManager;
+    errorHandler;
+    constructor() {
+        this.commandManager = ServiceContainer.getService(CommandManager);
+        this.guildDataGetter = ServiceContainer.getService(GuildDataGetter);
+        this.client = ServiceContainer.getService(Client);
+        this.translationManager = ServiceContainer.getService(TranslationManager);
+        this.eventManager = ServiceContainer.getService(EventManager);
+        this.errorHandler = ServiceContainer.getService(ErrorHandler);
+    }
+    async handleInteraction(interaction, params) {
+        if (interaction.isCommand()) {
+            if (params?.disabledHandlers?.includes("command"))
+                return;
+            await this.handleCommandInteraction(interaction);
+        }
+        else if (interaction.isButton()) {
+            if (params?.disabledHandlers?.includes("button"))
+                return;
+            await this.handleButtonInteraction(interaction);
+        }
+        else if (interaction.isStringSelectMenu()) {
+            if (params?.disabledHandlers?.includes("selectMenu"))
+                return;
+            await this.handleSelectMenu(interaction);
+        }
+        else if (interaction.isModalSubmit()) {
+            if (params?.disabledHandlers?.includes("modal"))
+                return;
+            await this.handleModalInteraction(interaction);
+        }
+    }
+    async handleCommandInteraction(interaction, guildSettings) {
+        const subcommandName = interaction.options.getSubcommand(false);
+        const commandName = interaction.commandName;
+        let commandInstance;
+        if (subcommandName) {
+            commandInstance = Array.from(this.commandManager.getAll().values()).find(c => c.name == subcommandName && c.parent == commandName);
+        }
+        else {
+            commandInstance = this.commandManager.get(commandName);
+        }
+        if (!commandInstance)
+            return;
+        const framework = ServiceContainer.getService(ZumitoFramework);
+        const args = new Map();
+        commandInstance.args.forEach((arg) => {
+            const option = (interaction).options.get(arg.name);
+            if (option) {
+                switch (arg.type) {
+                    case 'user':
+                        args.set(arg.name, option.user);
+                        break;
+                    case 'member':
+                        args.set(arg.name, option.member);
+                        break;
+                    default:
+                        args.set(arg.name, option.value ||
+                            option.user ||
+                            option.role ||
+                            option.channel ||
+                            option.options ||
+                            option.message ||
+                            option.member ||
+                            option.focused ||
+                            option.autocomplete ||
+                            option.attachment);
+                        break;
+                }
+            }
+        });
+        if (![CommandType.any, CommandType.separated, CommandType.slash,].includes(commandInstance.type))
+            return;
+        if (!guildSettings && interaction.guildId) {
+            guildSettings = await ServiceContainer.getService(GuildDataGetter).getGuildSettings(interaction.guildId);
+        }
+        const trans = this.translationManager.getShortHandMethod('command.' + commandInstance.name, guildSettings?.lang);
+        if (commandInstance.type === CommandType.separated ||
+            commandInstance.type === CommandType.slash) {
+            await commandInstance.executeSlashCommand({
+                client: this.client,
+                interaction, args, framework, guildSettings, trans,
+            });
+        }
+        else {
+            try {
+                await commandInstance.execute({
+                    client: this.client,
+                    interaction, args, framework, guildSettings, trans,
+                }).catch((error) => {
+                    this.errorHandler.handleError(error, {
+                        command: commandInstance,
+                        type: ErrorType.CommandRun,
+                    });
+                    interaction.reply({
+                        content: "An error ocurred while running this command.",
+                        ephemeral: true
+                    });
+                });
+            }
+            catch (error) {
+                this.errorHandler.handleError(error, {
+                    command: commandInstance,
+                    type: ErrorType.CommandRun,
+                });
+                interaction.reply({
+                    content: "An error ocurred while running this command.",
+                    ephemeral: true,
+                });
+            }
+        }
+    }
+    async handleButtonInteraction(interaction, guildSettings) {
+        const framework = ServiceContainer.getService(ZumitoFramework);
+        const path = interaction.customId.split('.');
+        const commandInstance = this.commandManager.get(path[0]);
+        if (!commandInstance)
+            throw new Error(`Command ${path[0]} not found or button id bad formatted`);
+        if (!guildSettings && interaction.guildId) {
+            guildSettings = await ServiceContainer.getService(GuildDataGetter).getGuildSettings(interaction.guildId);
+        }
+        // If the command has impements ButtonPress class then execute the method
+        if (commandInstance.constructor.prototype.hasOwnProperty('buttonPressed')) {
+            commandInstance.buttonPressed({
+                client: this.client,
+                path,
+                interaction,
+                framework,
+                guildSettings,
+            });
+        }
+    }
+    async handleSelectMenu(interaction, guildSettings) {
+        const path = interaction.customId.split('.');
+        const commandInstance = this.commandManager.get(path[0]);
+        if (!commandInstance)
+            throw new Error(`Command ${path[0]} not found or select menu id bad formatted`);
+        if (!guildSettings && interaction.guildId) {
+            guildSettings = await ServiceContainer.getService(GuildDataGetter).getGuildSettings(interaction.guildId);
+        }
+        const trans = this.translationManager.getShortHandMethod('command.' + commandInstance.name, guildSettings?.lang);
+        const framework = ServiceContainer.getService(ZumitoFramework);
+        if (commandInstance.binds?.selectMenu) {
+            commandInstance.binds?.selectMenu({
+                path,
+                interaction,
+                client: this.client,
+                framework,
+                guildSettings,
+                trans,
+            });
+        }
+        else if ( // Deprecated
+        commandInstance.constructor.prototype.hasOwnProperty('selectMenu')) {
+            commandInstance.selectMenu({
+                path,
+                interaction,
+                client: this.client,
+                framework,
+                guildSettings,
+                trans,
+            });
+        }
+    }
+    async handleModalInteraction(interaction, guildSettings) {
+        const path = interaction.customId.split('.');
+        const commandInstance = this.commandManager.get(path[0]);
+        if (!commandInstance) {
+            throw new Error(`Command ${path[0]} not found or modal id bad formatted`);
+        }
+        const framework = ServiceContainer.getService(ZumitoFramework);
+        if (commandInstance.modalSubmit) {
+            if (!guildSettings && interaction.guildId) {
+                guildSettings = await ServiceContainer.getService(GuildDataGetter).getGuildSettings(interaction.guildId);
+            }
+            commandInstance.modalSubmit({
+                client: this.client,
+                path,
+                interaction,
+                framework,
+                guildSettings,
+            });
+        }
+        else {
+            this.eventManager.emitEvent('modalSubmit', 'framework', {
+                client: this.client,
+                path, interaction, framework, guildSettings,
+            });
+        }
+    }
+}

package/dist/services/ServiceContainer.d.ts

@@ -1 +1,9 @@
-export declare const ServiceContainer: any;
+declare class ServiceContainerManager {
+    private services;
+    addService(serviceClass: any, dependencies: string[], singleton?: boolean, instance?: any): void;
+    getService<T>(serviceClass: new (...args: any[]) => T | string): T;
+    getServiceByName<T>(serviceName: string): T;
+    addInstance(serviceClass: any, instance: any): void;
+}
+export declare const ServiceContainer: ServiceContainerManager;
+export {};

package/dist/services/ServiceContainer.js

@@ -9,13 +9,25 @@ class ServiceContainerManager {
         });
     }
     getService(serviceClass) {
-        const serviceName = typeof serviceClass == 'string' ? serviceClass : serviceClass.name;
+        const serviceName = typeof serviceClass === 'string' ? serviceClass : serviceClass.name;
+        const service = this.services.get(serviceName);
+        if (!service)
+            throw new Error(`Service ${serviceName} not found`);
+        if (service.singleton && service.instance)
+            return service.instance;
+        const dependencies = service.dependencies.map(dependency => this.getServiceByName(dependency));
+        const instance = new service.class(...dependencies);
+        if (service.singleton)
+            service.instance = instance;
+        return instance;
+    }
+    getServiceByName(serviceName) {
         const service = this.services.get(serviceName);
         if (!service)
             throw new Error(`Service ${serviceName} not found`);
         if (service.singleton && service.instance)
             return service.instance;
-        const dependencies = service.dependencies.map(dependency => this.getService(dependency));
+        const dependencies = service.dependencies.map(dependency => this.getServiceByName(dependency));
         const instance = new service.class(...dependencies);
         if (service.singleton)
             service.instance = instance;

package/dist/services/SlashCommandRefresher.d.ts

@@ -1,6 +1,9 @@
 import { ZumitoFramework } from "../ZumitoFramework";
+import { Command } from "../definitions/commands/Command";
+import { SlashCommandSubcommandBuilder } from "discord.js";
 export declare class SlashCommandRefresher {
-    framework: ZumitoFramework;
+    protected framework: ZumitoFramework;
     constructor(framework: ZumitoFramework);
     refreshSlashCommands(): Promise<void>;
+    mapCommand(command: Command, commandBuilder?: SlashCommandSubcommandBuilder): import("discord.js").RESTPostAPIChatInputApplicationCommandsJSONBody | import("discord.js").APIApplicationCommandSubcommandOption;
 }

package/dist/services/SlashCommandRefresher.js

@@ -13,61 +13,78 @@ export class SlashCommandRefresher {
     async refreshSlashCommands() {
         const rest = new REST({ version: '10' }).setToken(this.framework.settings.discordClientOptions.token);
         const commands = Array.from(this.framework.commands.getAll().values())
-            .filter((command) => command.type == CommandType.slash ||
+            .filter((command) => (command.type == CommandType.slash ||
             command.type == CommandType.separated ||
             command.type == CommandType.any)
-            .map((command) => {
-            const slashCommand = new SlashCommandBuilder()
-                .setName(command.name)
-                .setDescription(this.framework.translations.get('command.' + command.name + '.description', 'en'));
-            if (command.args) {
-                command.args.forEach((arg) => {
-                    let method;
-                    switch (arg.type) {
-                        case 'string':
-                            method = 'addStringOption';
-                            break;
-                        case 'user':
-                        case 'member':
-                            method = 'addUserOption';
-                            break;
-                        case 'channel':
-                            method = 'addChannelOption';
-                            break;
-                        case 'role':
-                            method = 'addRoleOption';
-                            break;
-                        default:
-                            throw new Error('Invalid argument type ' + arg.type);
-                    }
-                    slashCommand[method]((option) => {
-                        option.setName(arg.name);
-                        option.setDescription(this.framework.translations.get('command.' +
-                            command.name +
-                            '.args.' +
-                            arg.name +
-                            '.description', 'en'));
-                        option.setRequired(!arg.optional);
-                        if (arg.choices) {
-                            // if arg.choices is function, call it
-                            if (typeof arg.choices == 'function') {
-                                arg.choices =
-                                    arg.choices();
-                            }
-                            arg.choices.forEach((choice) => {
-                                option.addChoices({
-                                    name: choice.name,
-                                    value: choice.value,
-                                });
-                            });
+            && !command.parent)
+            .map(command => this.mapCommand(command));
+        const data = await rest.put(Routes.applicationCommands(this.framework.settings.discordClientOptions.clientId), { body: commands });
+        console.debug(`Successfully reloaded ${data.length} of ${commands.length} application (/) commands.`);
+    }
+    mapCommand(command, commandBuilder) {
+        const slashCommand = commandBuilder || new SlashCommandBuilder();
+        slashCommand
+            .setName(command.name)
+            .setDescription(this.framework.translations.get('command.' + command.name + '.description', 'en'));
+        if (command.args) {
+            command.args.forEach((arg) => {
+                let method;
+                switch (arg.type) {
+                    case 'string':
+                        method = 'addStringOption';
+                        break;
+                    case 'user':
+                    case 'member':
+                        method = 'addUserOption';
+                        break;
+                    case 'channel':
+                        method = 'addChannelOption';
+                        break;
+                    case 'role':
+                        method = 'addRoleOption';
+                        break;
+                    default:
+                        throw new Error('Invalid argument type ' + arg.type);
+                }
+                slashCommand[method]((option) => {
+                    option.setName(arg.name);
+                    option.setDescription(this.framework.translations.get('command.' +
+                        command.name +
+                        '.args.' +
+                        arg.name +
+                        '.description', 'en'));
+                    option.setRequired(!arg.optional);
+                    if (arg.choices) {
+                        // if arg.choices is function, call it
+                        if (typeof arg.choices == 'function') {
+                            arg.choices =
+                                arg.choices();
                         }
-                        return option;
-                    });
+                        arg.choices.forEach((choice) => {
+                            option.addChoices({
+                                name: choice.name,
+                                value: choice.value,
+                            });
+                        });
+                    }
+                    return option;
+                });
+            });
+        }
+        Array.from(this.framework.commands.getAll().values())
+            .filter((subcommand) => (subcommand.type == CommandType.slash ||
+            subcommand.type == CommandType.separated ||
+            subcommand.type == CommandType.any)
+            && subcommand.parent
+            && subcommand.parent == command.name)
+            .forEach(subcommand => {
+            if (!commandBuilder) {
+                slashCommand.addSubcommand((subcommandSlashBuilder) => {
+                    this.mapCommand(subcommand, subcommandSlashBuilder);
+                    return subcommandSlashBuilder;
                 });
             }
-            return slashCommand.toJSON();
         });
-        const data = await rest.put(Routes.applicationCommands(this.framework.settings.discordClientOptions.clientId), { body: commands });
-        console.debug(`Successfully reloaded ${data.length} of ${commands.length} application (/) commands.`);
+        return slashCommand.toJSON();
     }
 }

package/dist/services/TranslationManager.d.ts

@@ -31,4 +31,5 @@ export declare class TranslationManager {
      */
     registerTranslationsFromFolder(folderPath: string, baseKey?: string, watch?: boolean): Promise<void>;
     watchTranslationFolder(folderPath: string, baseKey: string): void;
+    getShortHandMethod(keyPrefix: string, language?: string): (key: string, params?: any, lang?: string) => string;
 }

package/dist/services/TranslationManager.js

@@ -119,4 +119,16 @@ export class TranslationManager {
         // TODO: Handle file removal
         //.on('unlink', function(path) {console.log('File', path, 'has been removed');})
     }
+    getShortHandMethod(keyPrefix, language) {
+        return (key, params, lang) => {
+            if (key.startsWith('$')) {
+                return this.get(key.replace('$', ''), lang || language, params);
+            }
+            else {
+                if (!keyPrefix.endsWith('.'))
+                    keyPrefix += '.';
+                return this.get(keyPrefix + key, lang || language, params);
+            }
+        };
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.2.16",
+  "version": "1.2.18",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,6 +33,7 @@
     "express": "^4.18.1",
     "leven": "^4.0.0",
     "mongoose": "^6.6.5",
+    "source-fragment": "^1.1.0",
     "tingodb": "^0.6.1",
     "tseep": "^1.2.2",
     "zumito-db": "^1.0.0"
@@ -54,6 +55,10 @@
     ".": "./dist/index.js",
     "./discord": "./dist/discord/index.js"
   },
+  "_moduleAliases": {
+    "@definitions": "definitions",
+    "@services": "services"
+  },
   "typesVersions": {
     "*": {
       ".": [