zumito-framework 1.2.6 → 1.2.8

package/dist/ZumitoFramework.d.ts

@@ -144,58 +144,19 @@ export declare class ZumitoFramework {
      */
     private initializeDiscordClient;
     /**
-     * From a command-line string, returns an array of parameters.
-     * @param commandLine
-     * @returns {string[]}
-     * @private
-     * @static
-     * @example
-     * // returns ['a', 'b', 'c']
-     * splitCommandLine('a b c');
-     * @example
-     * // returns ['a', 'b c']
-     * splitCommandLine('a "b c"');
+     * @deprecated use CommandParser service instead
      */
     static splitCommandLine(commandLine: any): any;
     /**
-     * Checks if a member has a permission in a channel.
-     * @param member
-     * @param channel
-     * @param permission
-     * @returns {Promise<boolean>}
-     * @public
-     * @example
-     * // returns true if the member has the permission
-     * memberHasPermission(member, channel, Permissions.FLAGS.MANAGE_MESSAGES);
-     * @example
-     * // returns true if the member has the permission
-     * memberHasPermission(member, channel, Permissions.FLAGS.MANAGE_MESSAGES | Permissions.FLAGS.MANAGE_CHANNELS);
-     * @example
-     */
-    memberHasPermission(member: GuildMember, channel: TextChannel, permission: bigint): Promise<boolean>;
-    /**
-     * Gets the guild settings from the database.
-     * If the guild is not in the database, it is added.
-     * @param guildId
-     * @returns {Promise<any>}
-     * @public
-     * @async
-     * @example
-     * // returns the guild settings
-     * getGuildSettings('123456789012345678');
-     * @example
-     * // returns the guild settings
-     * getGuildSettings(guild.id);
-     * @example
-     * // returns the guild settings
-     * getGuildSettings(message.guild.id);
-     * @example
-     * // returns the guild settings
-     * getGuildSettings(interaction.guild.id);
-     * @example
-     * // returns the guild settings
-     * getGuildSettings(interaction.guildId);
+     * @deprecated use MemberPermissionChecker service
+     */
+    memberHasPermission(member: GuildMember, channel: TextChannel, permission: bigint): Promise<any>;
+    /**
+     * @deprecated use GuildDataGetter service
      */
     getGuildSettings(guildId: string): Promise<unknown>;
+    /**
+     * @deprecated
+     */
     refreshSlashCommands(): Promise<void>;
 }

package/dist/ZumitoFramework.js

@@ -1,11 +1,8 @@
 import * as fs from 'fs';
 import * as url from 'url';
-import { Client, SlashCommandBuilder, } from 'discord.js';
+import { Client, } from 'discord.js';
 import { ApiResponse } from './definitions/api/ApiResponse.js';
-import { CommandType } from './definitions/commands/CommandType.js';
 import { EventEmitter } from 'events';
-import { REST } from '@discordjs/rest';
-import { Routes } from 'discord-api-types/v9';
 import { StatusManager } from './services/StatusManager.js';
 import { TranslationManager } from './services/TranslationManager.js';
 import { betterLogging } from 'better-logging';
@@ -19,6 +16,11 @@ import { EventManager } from './services/EventManager.js';
 import { CommandManager } from './services/CommandManager.js';
 import { ModuleManager } from './services/ModuleManager.js';
 import { ServiceContainer } from './services/ServiceContainer.js';
+import { GuildDataGetter } from './services/GuildDataGetter.js';
+import { RecursiveObjectMerger } from './services/RecursiveObjectMerger.js';
+import { MemberPermissionChecker } from './services/MemberPermissionChecker.js';
+import { CommandParser } from './services/CommandParser.js';
+import { SlashCommandRefresher } from './services/SlashCommandRefresher.js';
 // import better-logging
 betterLogging(console);
 /**
@@ -127,6 +129,9 @@ export class ZumitoFramework {
      */
     constructor(settings, callback) {
         this.settings = settings;
+        // Register this class instance to service container
+        ServiceContainer.addService(ZumitoFramework, [], true, this);
+        ServiceContainer.addService(TranslationManager, [], true, this.translations);
         this.modules = new ModuleManager(this);
         this.commands = new CommandManager(this);
         this.events = new Map();
@@ -136,9 +141,6 @@ export class ZumitoFramework {
         if (settings.logLevel) {
             console.logLevel = settings.logLevel;
         }
-        // Register this class instance to service container
-        ServiceContainer.addService(ZumitoFramework, [], true, this);
-        ServiceContainer.addService(TranslationManager, [], true, this.translations);
         this.initialize()
             .then(() => {
             if (callback)
@@ -238,13 +240,16 @@ export class ZumitoFramework {
         else if (fs.existsSync(`${process.cwd()}/src/modules`)) {
             modulesFolder = `${process.cwd()}/src/modules`;
         }
-        else
-            return;
         const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
         await this.registerModule(path.join(__dirname, 'modules', 'core'), 'baseModule');
-        const files = fs.readdirSync(modulesFolder);
-        for (const file of files) {
-            await this.registerModule(modulesFolder, file);
+        if (modulesFolder) {
+            const files = fs.readdirSync(modulesFolder);
+            for (const file of files) {
+                await this.registerModule(modulesFolder, file);
+            }
+        }
+        else if (this.settings.srcMode == 'monoBundle') {
+            await this.registerModule(process.cwd(), 'src');
         }
         // Define models
         const schemas = {};
@@ -253,7 +258,7 @@ export class ZumitoFramework {
                 schemas[model.name] = model.getModel(this.database);
             }
             else {
-                schemas[model.name] = MergeRecursive(schemas[model.name], model.getModel(this.database));
+                schemas[model.name] = RecursiveObjectMerger.merge(schemas[model.name], model.getModel(this.database));
             }
         });
         Object.keys(schemas).forEach((schemaName) => {
@@ -292,182 +297,30 @@ export class ZumitoFramework {
         });
     }
     /**
-     * From a command-line string, returns an array of parameters.
-     * @param commandLine
-     * @returns {string[]}
-     * @private
-     * @static
-     * @example
-     * // returns ['a', 'b', 'c']
-     * splitCommandLine('a b c');
-     * @example
-     * // returns ['a', 'b c']
-     * splitCommandLine('a "b c"');
+     * @deprecated use CommandParser service instead
      */
     static splitCommandLine(commandLine) {
-        //log( 'commandLine', commandLine ) ;
-        //  Find a unique marker for the space character.
-        //  Start with '<SP>' and repeatedly append '@' if necessary to make it unique.
-        let spaceMarker = '<SP>';
-        while (commandLine.indexOf(spaceMarker) > -1)
-            spaceMarker += '@';
-        //  Protect double-quoted strings.
-        //   o  Find strings of non-double-quotes, wrapped in double-quotes.
-        //   o  The final double-quote is optional to allow for an unterminated string.
-        //   o  Replace each double-quoted-string with what's inside the qouble-quotes,
-        //      after each space character has been replaced with the space-marker above.
-        //   o  The outer double-quotes will not be present.
-        const noSpacesInQuotes = commandLine.replace(/"([^"]*)"?/g, (fullMatch, capture) => {
-            return capture.replace(/ /g, spaceMarker);
-        });
-        //  Now that it is safe to do so, split the command-line at one-or-more spaces.
-        const mangledParamArray = noSpacesInQuotes.split(/ +/);
-        //  Create a new array by restoring spaces from any space-markers.
-        const paramArray = mangledParamArray.map((mangledParam) => {
-            return mangledParam.replace(RegExp(spaceMarker, 'g'), ' ');
-        });
-        return paramArray;
+        return CommandParser.splitCommandLine(commandLine);
     }
     /**
-     * Checks if a member has a permission in a channel.
-     * @param member
-     * @param channel
-     * @param permission
-     * @returns {Promise<boolean>}
-     * @public
-     * @example
-     * // returns true if the member has the permission
-     * memberHasPermission(member, channel, Permissions.FLAGS.MANAGE_MESSAGES);
-     * @example
-     * // returns true if the member has the permission
-     * memberHasPermission(member, channel, Permissions.FLAGS.MANAGE_MESSAGES | Permissions.FLAGS.MANAGE_CHANNELS);
-     * @example
+     * @deprecated use MemberPermissionChecker service
      */
     async memberHasPermission(member, channel, permission) {
-        const memberPermission = await channel.permissionsFor(member);
-        return memberPermission.has(permission);
+        const memberPermissionChecker = ServiceContainer.getService(MemberPermissionChecker);
+        return await memberPermissionChecker(member, channel, permission);
     }
     /**
-     * Gets the guild settings from the database.
-     * If the guild is not in the database, it is added.
-     * @param guildId
-     * @returns {Promise<any>}
-     * @public
-     * @async
-     * @example
-     * // returns the guild settings
-     * getGuildSettings('123456789012345678');
-     * @example
-     * // returns the guild settings
-     * getGuildSettings(guild.id);
-     * @example
-     * // returns the guild settings
-     * getGuildSettings(message.guild.id);
-     * @example
-     * // returns the guild settings
-     * getGuildSettings(interaction.guild.id);
-     * @example
-     * // returns the guild settings
-     * getGuildSettings(interaction.guildId);
+     * @deprecated use GuildDataGetter service
      */
     async getGuildSettings(guildId) {
-        const Guild = this.database.models.Guild;
-        return await new Promise((resolve, reject) => {
-            Guild.findOne({ where: { guild_id: guildId } }, (err, guild) => {
-                if (err)
-                    reject(err);
-                if (guild == null) {
-                    guild = new Guild({
-                        guild_id: guildId,
-                    });
-                    guild.save((err) => {
-                        if (err)
-                            reject(err);
-                        resolve(guild);
-                    });
-                }
-                else {
-                    resolve(guild);
-                }
-            });
-        });
+        const guildDataGetter = ServiceContainer.getService(GuildDataGetter);
+        return await guildDataGetter.getGuildSettings(guildId);
     }
+    /**
+     * @deprecated
+     */
     async refreshSlashCommands() {
-        const rest = new REST({ version: '10' }).setToken(this.settings.discordClientOptions.token);
-        const commands = Array.from(this.commands.getAll().values())
-            .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.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.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,
-                                });
-                            });
-                        }
-                        return option;
-                    });
-                });
-            }
-            return slashCommand.toJSON();
-        });
-        const data = await rest.put(Routes.applicationCommands(this.settings.discordClientOptions.clientId), { body: commands });
-        console.debug(`Successfully reloaded ${data.length} of ${commands.length} application (/) commands.`);
-    }
-}
-function MergeRecursive(obj1, obj2) {
-    for (const p in obj2) {
-        try {
-            // Property in destination object set; update its value.
-            if (obj2[p].constructor == Object) {
-                obj1[p] = MergeRecursive(obj1[p], obj2[p]);
-            }
-            else {
-                obj1[p] = obj2[p];
-            }
-        }
-        catch (e) {
-            // Property in destination object not set; create it and set its value.
-            obj1[p] = obj2[p];
-        }
+        const slashCommandRefresher = ServiceContainer.getService(SlashCommandRefresher);
+        slashCommandRefresher.refreshSlashCommands();
     }
-    return obj1;
 }

package/dist/definitions/CommandLoadOptions.d.ts

@@ -0,0 +1,7 @@
+export declare type CommandLoadOptions = {
+    whitelist?: string[];
+    blacklist?: string[];
+    renames?: {
+        [key: string]: string;
+    };
+};

package/dist/definitions/CommandLoadOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/definitions/ErrorType.d.ts

@@ -0,0 +1,5 @@
+export declare enum ErrorType {
+    CommandInstance = 1,
+    CommandLoad = 2,
+    CommandRun = 3
+}

package/dist/definitions/ErrorType.js

@@ -0,0 +1,6 @@
+export var ErrorType;
+(function (ErrorType) {
+    ErrorType[ErrorType["CommandInstance"] = 1] = "CommandInstance";
+    ErrorType[ErrorType["CommandLoad"] = 2] = "CommandLoad";
+    ErrorType[ErrorType["CommandRun"] = 3] = "CommandRun";
+})(ErrorType || (ErrorType = {}));

package/dist/definitions/FrameworkSettings.d.ts

@@ -10,4 +10,5 @@ export interface FrameworkSettings {
     };
     defaultPrefix?: string;
     statusOptions?: StatusManagerOptions;
+    srcMode?: 'multiBundle' | 'monoBundle' | undefined;
 }

package/dist/definitions/Module.d.ts

@@ -3,14 +3,16 @@ import { Command } from './commands/Command.js';
 import { FrameworkEvent } from './FrameworkEvent.js';
 import { DatabaseModel } from './DatabaseModel.js';
 import { CommandManager } from '../services/CommandManager.js';
+import { ModuleParameters } from './parameters/ModuleParameters.js';
 export declare abstract class Module {
     protected path: string;
+    protected parameters: ModuleParameters;
     protected framework: ZumitoFramework;
     protected commands: CommandManager;
     protected events: Map<string, FrameworkEvent>;
     protected models: Array<DatabaseModel>;
     protected commandManager: CommandManager;
-    constructor(path: any, framework: any);
+    constructor(path: any, parameters?: ModuleParameters);
     initialize(): Promise<void>;
     registerCommands(): Promise<void>;
     getCommands(): Map<string, Command>;

package/dist/definitions/Module.js

@@ -1,18 +1,22 @@
+import { ZumitoFramework } from '../ZumitoFramework.js';
 import * as fs from 'fs';
 import path from 'path';
 import { ButtonInteraction, CommandInteraction, ModalSubmitInteraction, StringSelectMenuInteraction, } from 'discord.js';
 import { CommandManager } from '../services/CommandManager.js';
+import { ServiceContainer } from '../services/ServiceContainer.js';
 export class Module {
     path;
+    parameters;
     framework;
     commands;
     events = new Map();
     models = [];
     commandManager;
-    constructor(path, framework) {
+    constructor(path, parameters) {
         this.path = path;
-        this.framework = framework;
-        this.commands = new CommandManager(framework);
+        this.parameters = parameters;
+        this.framework = ServiceContainer.getService(ZumitoFramework);
+        this.commands = new CommandManager(this.framework);
     }
     async initialize() {
         await this.registerCommands();

package/dist/definitions/parameters/ModuleParameters.d.ts

@@ -0,0 +1,7 @@
+export declare type ModuleParameters = {
+    commandWhitelist?: string[];
+    commandBlacklist?: string[];
+    commandRenames?: {
+        [key: string]: string;
+    };
+};

package/dist/definitions/parameters/ModuleParameters.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -22,4 +22,8 @@ import { ZumitoFramework } from './ZumitoFramework.js';
 import * as discord from 'discord.js';
 import { EventParameters } from './definitions/parameters/EventParameters.js';
 import { ServiceContainer } from './services/ServiceContainer.js';
-export { ZumitoFramework, FrameworkSettings, Command, Module, CommandParameters, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, SelectMenuParameters, CommandType, CommandArgDefinition, CommandChoiceDefinition, ButtonPressed, ButtonPressedParams, TextFormatter, EmojiFallback, DatabaseConfigLoader, DatabaseModel, PresenceDataRule, RuledPresenceData, StatusManagerOptions, discord, EventParameters, ServiceContainer };
+import { GuildDataGetter } from './services/GuildDataGetter.js';
+import { CommandParser } from './services/CommandParser.js';
+import { SlashCommandRefresher } from './services/SlashCommandRefresher.js';
+import { ErrorHandler } from './services/ErrorHandler.js';
+export { ZumitoFramework, FrameworkSettings, Command, Module, CommandParameters, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, SelectMenuParameters, CommandType, CommandArgDefinition, CommandChoiceDefinition, ButtonPressed, ButtonPressedParams, TextFormatter, EmojiFallback, DatabaseConfigLoader, DatabaseModel, PresenceDataRule, RuledPresenceData, StatusManagerOptions, discord, EventParameters, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, ErrorHandler, };

package/dist/index.js

@@ -14,6 +14,16 @@ import { TranslationManager } from './services/TranslationManager.js';
 import { ZumitoFramework } from './ZumitoFramework.js';
 import * as discord from 'discord.js';
 import { ServiceContainer } from './services/ServiceContainer.js';
+import { GuildDataGetter } from './services/GuildDataGetter.js';
+import { MemberPermissionChecker } from './services/MemberPermissionChecker.js';
+import { CommandParser } from './services/CommandParser.js';
+import { SlashCommandRefresher } from './services/SlashCommandRefresher.js';
+import { ErrorHandler } from './services/ErrorHandler.js';
 ServiceContainer.addService(TextFormatter, []);
 ServiceContainer.addService(EmojiFallback, []);
-export { ZumitoFramework, Command, Module, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, CommandType, ButtonPressed, TextFormatter, EmojiFallback, DatabaseConfigLoader, DatabaseModel, discord, ServiceContainer };
+ServiceContainer.addService(GuildDataGetter, [ZumitoFramework.name]);
+ServiceContainer.addService(MemberPermissionChecker, []);
+ServiceContainer.addService(CommandParser, []);
+ServiceContainer.addService(SlashCommandRefresher, [ZumitoFramework.name]);
+ServiceContainer.addService(ErrorHandler, ['ZumitoFramework']);
+export { ZumitoFramework, Command, Module, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, CommandType, ButtonPressed, TextFormatter, EmojiFallback, DatabaseConfigLoader, DatabaseModel, discord, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, ErrorHandler, };

package/dist/services/CommandManager.d.ts

@@ -1,8 +1,11 @@
 import { ZumitoFramework } from "../ZumitoFramework";
 import { Command } from "../definitions/commands/Command.js";
+import { CommandLoadOptions } from "../definitions/CommandLoadOptions";
+import { ErrorHandler } from "./ErrorHandler";
 export declare class CommandManager {
     protected commands: Map<string, Command>;
     protected framework: ZumitoFramework;
+    protected errorHandler: ErrorHandler;
     constructor(framework: any);
     set(name: string, command: Command): void;
     get(name: string): Command;
@@ -26,7 +29,7 @@ export declare class CommandManager {
      * @param folderPath - Absolute path to commands folder
      * @returns {Promise<Map<string, Command>>}
      */
-    loadCommandsFolder(folderPath: string): Promise<Map<string, any>>;
+    loadCommandsFolder(folderPath: string, options?: CommandLoadOptions): Promise<Map<string, any>>;
     /**
      * Watch command files on a folder.
      * It loads command when new file is created, update command when file is modified and deletes command when file is deleted.

package/dist/services/CommandManager.js

@@ -5,11 +5,16 @@ import boxen from "boxen";
 import fs from 'fs';
 import { REST, Routes, SlashCommandBuilder } from "discord.js";
 import { CommandType } from "../definitions/commands/CommandType.js";
+import { ErrorHandler } from "./ErrorHandler";
+import { ServiceContainer } from "./ServiceContainer";
+import { ErrorType } from "../definitions/ErrorType";
 export class CommandManager {
     commands;
     framework;
+    errorHandler;
     constructor(framework) {
         this.commands = new Map;
+        this.errorHandler = ServiceContainer.getService(ErrorHandler);
         this.framework = framework;
     }
     set(name, command) {
@@ -45,7 +50,15 @@ export class CommandManager {
             console.log(e + '\n' + e.name + '\n' + e.stack);
         });
         command = Object.values(command)[0];
-        command = new command();
+        try {
+            command = new command();
+        }
+        catch (error) {
+            this.errorHandler.handleError(error, {
+                type: ErrorType.CommandInstance,
+                command: command,
+            });
+        }
         this.framework.commands.set(command.constructor.name.toLowerCase(), command);
         console.debug('[🆕🟢 ] Command ' + chalk.blue(filePath.toString().replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')) + ' loaded');
         return command;
@@ -57,14 +70,19 @@ export class CommandManager {
      * @param folderPath - Absolute path to commands folder
      * @returns {Promise<Map<string, Command>>}
      */
-    async loadCommandsFolder(folderPath) {
+    async loadCommandsFolder(folderPath, options) {
         const files = fs.readdirSync(folderPath);
         for (const file of files) {
             if (file.endsWith('d.ts'))
                 continue;
             if (file.endsWith('.js') || file.endsWith('.ts')) {
                 const command = await this.loadCommandFile(path.join(folderPath, file));
-                this.commands.set(command.constructor.name.toLowerCase(), command);
+                const commandName = command.constructor.name.toLowerCase();
+                if (options?.blacklist && options.blacklist.includes(commandName))
+                    continue;
+                if (options?.whitelist && !options.whitelist.includes(commandName))
+                    continue;
+                this.commands.set(options?.renames?.[commandName] || commandName, command);
             }
         }
         return this.commands;

package/dist/services/CommandParser.d.ts

@@ -0,0 +1,16 @@
+export declare class CommandParser {
+    /**
+     * From a command-line string, returns an array of parameters.
+     * @param commandLine
+     * @returns {string[]}
+     * @private
+     * @static
+     * @example
+     * // returns ['a', 'b', 'c']
+     * splitCommandLine('a b c');
+     * @example
+     * // returns ['a', 'b c']
+     * splitCommandLine('a "b c"');
+     */
+    static splitCommandLine(commandLine: any): any;
+}

package/dist/services/CommandParser.js

@@ -0,0 +1,39 @@
+export class CommandParser {
+    /**
+     * From a command-line string, returns an array of parameters.
+     * @param commandLine
+     * @returns {string[]}
+     * @private
+     * @static
+     * @example
+     * // returns ['a', 'b', 'c']
+     * splitCommandLine('a b c');
+     * @example
+     * // returns ['a', 'b c']
+     * splitCommandLine('a "b c"');
+     */
+    static splitCommandLine(commandLine) {
+        //log( 'commandLine', commandLine ) ;
+        //  Find a unique marker for the space character.
+        //  Start with '<SP>' and repeatedly append '@' if necessary to make it unique.
+        let spaceMarker = '<SP>';
+        while (commandLine.indexOf(spaceMarker) > -1)
+            spaceMarker += '@';
+        //  Protect double-quoted strings.
+        //   o  Find strings of non-double-quotes, wrapped in double-quotes.
+        //   o  The final double-quote is optional to allow for an unterminated string.
+        //   o  Replace each double-quoted-string with what's inside the qouble-quotes,
+        //      after each space character has been replaced with the space-marker above.
+        //   o  The outer double-quotes will not be present.
+        const noSpacesInQuotes = commandLine.replace(/"([^"]*)"?/g, (fullMatch, capture) => {
+            return capture.replace(/ /g, spaceMarker);
+        });
+        //  Now that it is safe to do so, split the command-line at one-or-more spaces.
+        const mangledParamArray = noSpacesInQuotes.split(/ +/);
+        //  Create a new array by restoring spaces from any space-markers.
+        const paramArray = mangledParamArray.map((mangledParam) => {
+            return mangledParam.replace(RegExp(spaceMarker, 'g'), ' ');
+        });
+        return paramArray;
+    }
+}

package/dist/services/ErrorHandler.d.ts

@@ -0,0 +1,19 @@
+import { ErrorType } from "../definitions/ErrorType";
+import { Command } from "../definitions/commands/Command";
+import { ZumitoFramework } from "../ZumitoFramework";
+declare type BaseErrorOptions = {
+    exit?: boolean;
+    type: ErrorType;
+};
+declare type CommandErrorOptions = BaseErrorOptions & {
+    type: ErrorType.CommandInstance | ErrorType.CommandLoad | ErrorType.CommandRun;
+    command: Command;
+};
+export declare class ErrorHandler {
+    framework: ZumitoFramework;
+    constructor(framework: ZumitoFramework);
+    handleError(error: Error, options: BaseErrorOptions | CommandErrorOptions): void;
+    handleCommandError(error: Error, options: CommandErrorOptions): void;
+    printErrorStack(error: Error): void;
+}
+export {};

package/dist/services/ErrorHandler.js

@@ -0,0 +1,49 @@
+import ErrorStackParser from "error-stack-parser";
+import { ErrorType } from "../definitions/ErrorType";
+import chalk from "chalk";
+export class ErrorHandler {
+    framework;
+    constructor(framework) {
+        this.framework = framework;
+    }
+    handleError(error, options) {
+        if (options?.type == ErrorType.CommandInstance || options?.type == ErrorType.CommandLoad || options?.type == ErrorType.CommandRun) {
+            this.handleCommandError(error, options);
+        }
+        else {
+            console.error(error.toString());
+        }
+        this.printErrorStack(error);
+        if (options.exit)
+            process.exit(1);
+    }
+    handleCommandError(error, options) {
+        switch (options.type) {
+            case ErrorType.CommandInstance:
+                console.group(`[❌] Error instanciating command ${options.command.name}`);
+                break;
+            case ErrorType.CommandLoad:
+                console.group(`[❌] Error loading command ${options.command.name}`);
+                break;
+            case ErrorType.CommandRun:
+                console.group(`[❌] Error running command ${options.command.name}`);
+                break;
+        }
+        console.line(error.toString());
+        console.groupEnd();
+    }
+    printErrorStack(error) {
+        const stackParsedError = ErrorStackParser.parse(error);
+        let functionColor = 'blue';
+        for (let stack of stackParsedError) {
+            const filePath = stack.getFileName();
+            let functionName = stack.getFunctionName();
+            if (functionName == 'CommandManager.loadCommandFile') {
+                functionColor = 'yellow';
+            }
+            console.line(`    at ${chalk.gray(filePath)}:${stack.getLineNumber()}:${stack.getColumnNumber()} ${chalk[functionColor](functionName)}`);
+            if (functionName == 'CommandManager.loadCommandFile' && !this.framework.settings.debug)
+                break;
+        }
+    }
+}

package/dist/services/GuildDataGetter.d.ts

@@ -0,0 +1,29 @@
+import { ZumitoFramework } from "../ZumitoFramework";
+export declare class GuildDataGetter {
+    framework: ZumitoFramework;
+    constructor(framework: ZumitoFramework);
+    /**
+     * Gets the guild settings from the database.
+     * If the guild is not in the database, it is added.
+     * @param guildId
+     * @returns {Promise<any>}
+     * @public
+     * @async
+     * @example
+     * // returns the guild settings
+     * getGuildSettings('123456789012345678');
+     * @example
+     * // returns the guild settings
+     * getGuildSettings(guild.id);
+     * @example
+     * // returns the guild settings
+     * getGuildSettings(message.guild.id);
+     * @example
+     * // returns the guild settings
+     * getGuildSettings(interaction.guild.id);
+     * @example
+     * // returns the guild settings
+     * getGuildSettings(interaction.guildId);
+     */
+    getGuildSettings(guildId: string): Promise<unknown>;
+}

package/dist/services/GuildDataGetter.js

@@ -0,0 +1,51 @@
+export class GuildDataGetter {
+    framework;
+    constructor(framework) {
+        this.framework = framework;
+    }
+    /**
+     * Gets the guild settings from the database.
+     * If the guild is not in the database, it is added.
+     * @param guildId
+     * @returns {Promise<any>}
+     * @public
+     * @async
+     * @example
+     * // returns the guild settings
+     * getGuildSettings('123456789012345678');
+     * @example
+     * // returns the guild settings
+     * getGuildSettings(guild.id);
+     * @example
+     * // returns the guild settings
+     * getGuildSettings(message.guild.id);
+     * @example
+     * // returns the guild settings
+     * getGuildSettings(interaction.guild.id);
+     * @example
+     * // returns the guild settings
+     * getGuildSettings(interaction.guildId);
+     */
+    async getGuildSettings(guildId) {
+        const Guild = this.framework.database.models.Guild;
+        return await new Promise((resolve, reject) => {
+            Guild.findOne({ where: { guild_id: guildId } }, (err, guild) => {
+                if (err)
+                    reject(err);
+                if (guild == null) {
+                    guild = new Guild({
+                        guild_id: guildId,
+                    });
+                    guild.save((err) => {
+                        if (err)
+                            reject(err);
+                        resolve(guild);
+                    });
+                }
+                else {
+                    resolve(guild);
+                }
+            });
+        });
+    }
+}

package/dist/services/MemberPermissionChecker.d.ts

@@ -0,0 +1,19 @@
+import { GuildMember, TextChannel } from "discord.js";
+export declare class MemberPermissionChecker {
+    /**
+     * Checks if a member has a permission in a channel.
+     * @param member
+     * @param channel
+     * @param permission
+     * @returns {Promise<boolean>}
+     * @public
+     * @example
+     * // returns true if the member has the permission
+     * memberHasPermission(member, channel, Permissions.FLAGS.MANAGE_MESSAGES);
+     * @example
+     * // returns true if the member has the permission
+     * memberHasPermission(member, channel, Permissions.FLAGS.MANAGE_MESSAGES | Permissions.FLAGS.MANAGE_CHANNELS);
+     * @example
+     */
+    hasPermissionOnChannel(member: GuildMember, channel: TextChannel, permission: bigint): Promise<boolean>;
+}

package/dist/services/MemberPermissionChecker.js

@@ -0,0 +1,21 @@
+export class MemberPermissionChecker {
+    /**
+     * Checks if a member has a permission in a channel.
+     * @param member
+     * @param channel
+     * @param permission
+     * @returns {Promise<boolean>}
+     * @public
+     * @example
+     * // returns true if the member has the permission
+     * memberHasPermission(member, channel, Permissions.FLAGS.MANAGE_MESSAGES);
+     * @example
+     * // returns true if the member has the permission
+     * memberHasPermission(member, channel, Permissions.FLAGS.MANAGE_MESSAGES | Permissions.FLAGS.MANAGE_CHANNELS);
+     * @example
+     */
+    async hasPermissionOnChannel(member, channel, permission) {
+        const memberPermission = await channel.permissionsFor(member);
+        return memberPermission.has(permission);
+    }
+}

package/dist/services/ModuleManager.js

@@ -61,7 +61,7 @@ export class ModuleManager {
         let moduleInstance;
         if (module.constructor) {
             try {
-                moduleInstance = new module(rootPath, this.framework);
+                moduleInstance = new module(rootPath);
                 await moduleInstance.initialize();
                 this.modules.set(name || moduleInstance.constructor.name, moduleInstance);
             }

package/dist/services/RecursiveObjectMerger.d.ts

@@ -0,0 +1,3 @@
+export declare class RecursiveObjectMerger {
+    static merge(obj1: any, obj2: any): any;
+}

package/dist/services/RecursiveObjectMerger.js

@@ -0,0 +1,20 @@
+export class RecursiveObjectMerger {
+    static merge(obj1, obj2) {
+        for (const p in obj2) {
+            try {
+                // Property in destination object set; update its value.
+                if (obj2[p].constructor == Object) {
+                    obj1[p] = this.merge(obj1[p], obj2[p]);
+                }
+                else {
+                    obj1[p] = obj2[p];
+                }
+            }
+            catch (e) {
+                // Property in destination object not set; create it and set its value.
+                obj1[p] = obj2[p];
+            }
+        }
+        return obj1;
+    }
+}

package/dist/services/ServiceContainer.js

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

package/dist/services/SlashCommandRefresher.d.ts

@@ -0,0 +1,6 @@
+import { ZumitoFramework } from "../ZumitoFramework";
+export declare class SlashCommandRefresher {
+    framework: ZumitoFramework;
+    constructor(framework: ZumitoFramework);
+    refreshSlashCommands(): Promise<void>;
+}

package/dist/services/SlashCommandRefresher.js

@@ -0,0 +1,73 @@
+import { REST } from '@discordjs/rest';
+import { Routes } from 'discord-api-types/v9';
+import { CommandType } from "../definitions/commands/CommandType";
+import { SlashCommandBuilder } from "discord.js";
+export class SlashCommandRefresher {
+    framework;
+    constructor(framework) {
+        this.framework = framework;
+    }
+    /*
+    * Update slash commands on discord
+    */
+    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 ||
+            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,
+                                });
+                            });
+                        }
+                        return option;
+                    });
+                });
+            }
+            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.`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",