zumito-framework 1.2.7 → 1.2.8

package/dist/ZumitoFramework.js

@@ -129,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();
@@ -138,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)

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/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

@@ -25,4 +25,5 @@ import { ServiceContainer } from './services/ServiceContainer.js';
 import { GuildDataGetter } from './services/GuildDataGetter.js';
 import { CommandParser } from './services/CommandParser.js';
 import { SlashCommandRefresher } from './services/SlashCommandRefresher.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, };
+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

@@ -18,10 +18,12 @@ 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, []);
 ServiceContainer.addService(GuildDataGetter, [ZumitoFramework.name]);
 ServiceContainer.addService(MemberPermissionChecker, []);
 ServiceContainer.addService(CommandParser, []);
 ServiceContainer.addService(SlashCommandRefresher, [ZumitoFramework.name]);
-export { ZumitoFramework, Command, Module, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, CommandType, ButtonPressed, TextFormatter, EmojiFallback, DatabaseConfigLoader, DatabaseModel, discord, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, };
+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/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/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/ServiceContainer.js

@@ -9,10 +9,10 @@ class ServiceContainerManager {
         });
     }
     getService(serviceClass) {
-        const classname = typeof serviceClass === 'string' ? serviceClass : serviceClass.name;
-        const service = this.services.get(classname);
+        const serviceName = typeof serviceClass == 'string' ? serviceClass : serviceClass.name;
+        const service = this.services.get(serviceName);
         if (!service)
-            throw new Error(`Service ${classname} 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));
@@ -22,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/package.json

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