@expressive-tea/core 2.0.0

package/engines/teacup/index.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return */
+const chalk = require("chalk");
+const url_1 = require("url");
+const socket_io_client_1 = require("socket.io-client");
+const inversify_1 = require("inversify");
+const commons_1 = require("@expressive-tea/commons");
+const commons_2 = require("@expressive-tea/commons");
+const teapot_helper_1 = require("../../helpers/teapot-helper");
+const commons_3 = require("@expressive-tea/commons");
+const Engine_1 = require("../../classes/Engine");
+let TeacupEngine = class TeacupEngine extends Engine_1.default {
+    constructor() {
+        super(...arguments);
+        this.isStopping = false;
+    }
+    header() {
+        console.log(chalk.white.bold('Teacup Engine is initializing...'));
+        console.log(chalk `
+   {grey ( (}
+    {white.bold ) )}
+  {magenta.bold ........}
+  {magenta.bold |      |]}
+  {magenta.bold \\      /}    {yellow.bold [${this.teacupSettings.address}]}
+   {magenta.bold \`----'}
+
+{yellow.bold NOTICE:}
+All Communication are encrypted to ensure intruder can not connected, however, please does not share any sensitive data like keys or passwords to avoid security issues.
+  `);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handshaked(key, signature, isSecure, cb) {
+        try {
+            console.log(chalk `{cyan.bold [TEACUP]} - [{magenta.bold ${this.client.id}}]: {yellow.bold Server Verification Started}`);
+            if (!teapot_helper_1.default.verify(this.teacupSettings.clientKey, key.toString('ascii'), signature)) {
+                throw new Error('Fail to Verify Client on Teapod.');
+            }
+            console.log(chalk `{cyan.bold [TEACUP]} - [{magenta.bold ${this.client.id}}]: {green.bold Server Has Been Verified}`);
+            this.publicServerKey = key;
+            this.serverSignature = signature;
+            cb(Buffer.from(this.publicKey), this.clientSignature);
+        }
+        catch (e) {
+            const error = e;
+            console.error(chalk `{cyan.bold [TEACUP]} - {red.bold TEAPOD}  {magenta.bold ${this.client.id}}: Failed with next message: ${error.message}`);
+            this.client.disconnect();
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    accepted(cb) {
+        var _a;
+        console.log(chalk `{cyan.bold [TEACUP]} - [{magenta.bold ${this.client.id}}]: {green.bold Registered} - {blue.bold <${this.teacupSettings.serverUrl}>} <-> {white.bold ${this.teacupSettings.mountTo}}`);
+        const encryptedMessage = teapot_helper_1.default.encrypt({
+            mountTo: this.teacupSettings.mountTo,
+            address: this.teacupSettings.address
+        }, this.serverSignature);
+        cb(encryptedMessage);
+        const onClose = () => {
+            try {
+                this.client.close();
+            }
+            catch (_a) {
+                // Intentionally empty - ignore close errors
+            }
+        };
+        this.server.on('close', onClose);
+        (_a = this.serverSecure) === null || _a === void 0 ? void 0 : _a.on('close', onClose);
+    }
+    async start() {
+        this.teacupSettings = commons_1.Metadata.get(commons_2.ASSIGN_TEACUP_KEY, (0, commons_3.getClass)(this.context));
+        const scheme = new url_1.URL(this.teacupSettings.serverUrl);
+        const { publicKey, privateKey } = teapot_helper_1.default.generateKeys(this.teacupSettings.clientKey);
+        const protocol = teapot_helper_1.default.httpSchema(scheme.protocol);
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
+        this.clientSignature = teapot_helper_1.default.sign(this.teacupSettings.clientKey, this.privateKey, this.teacupSettings.clientKey);
+        this.client = (0, socket_io_client_1.io)(`${protocol}//${scheme.host}/teapot`, {
+            path: '/exp-tea/',
+            reconnection: true,
+            autoConnect: false
+        });
+        this.header();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        this.client.on('handshake', this.handshaked.bind(this));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        this.client.on('accepted', this.accepted.bind(this));
+        this.client.on('error', console.log);
+        this.client.connect();
+    }
+    static canRegister(ctx) {
+        return commons_1.Metadata.get(commons_2.ASSIGN_TEACUP_KEY, (0, commons_3.getClass)(ctx), 'isTeacupActive');
+    }
+    /**
+     * Graceful shutdown for TeacupEngine
+     *
+     * Disconnects the socket.io-client connection and prevents automatic reconnection.
+     * This method is idempotent and safe to call multiple times.
+     *
+     * @returns {Promise<void>} Promise that resolves when cleanup is complete
+     * @since 2.0.0
+     */
+    async stop() {
+        // Prevent multiple stop calls from racing
+        if (this.isStopping) {
+            return;
+        }
+        this.isStopping = true;
+        if (this.client) {
+            try {
+                // Disable reconnection before disconnecting to prevent automatic reconnect attempts
+                this.client.io.opts.reconnection = false;
+                // Remove all listeners to prevent any callbacks during shutdown
+                this.client.removeAllListeners();
+                // Disconnect the socket
+                if (this.client.connected) {
+                    this.client.disconnect();
+                }
+                // Close the underlying manager to release all resources
+                this.client.close();
+                console.log('[TEACUP] - Socket connection closed gracefully');
+            }
+            catch (e) {
+                // Log but don't throw - we want shutdown to complete even if cleanup has issues
+                const error = e;
+                console.error(`[TEACUP] - Error during shutdown: ${error.message}`);
+            }
+        }
+    }
+};
+TeacupEngine = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    (0, inversify_1.injectFromBase)({ extendConstructorArguments: true })
+], TeacupEngine);
+exports.default = TeacupEngine;

package/engines/teapot/index.d.ts

@@ -0,0 +1,32 @@
+import ExpressiveTeaEngine from '../../classes/Engine';
+import Boot from '../../classes/Boot';
+export default class TeapotEngine extends ExpressiveTeaEngine {
+    private readonly clients;
+    private readonly registeredRoute;
+    private teapotSettings;
+    private publicKey;
+    private privateKey;
+    private serverSignature;
+    private socketServer;
+    private isStopped;
+    private static header;
+    private registerTeacup;
+    private clientVerification;
+    private registered;
+    private removeFromRoutes;
+    private findClientInRoutes;
+    private disconnected;
+    init(): Promise<void>;
+    start(): Promise<void>;
+    /**
+     * Graceful shutdown for the Teapot engine.
+     *
+     * Disconnects all connected Teacup clients, closes the Socket.IO namespace,
+     * and clears internal state. This method is idempotent and safe to call multiple times.
+     *
+     * @returns {Promise<void>} Promise that resolves when cleanup is complete
+     * @since 2.0.0
+     */
+    stop(): Promise<void>;
+    static canRegister(ctx?: Boot): boolean;
+}

package/engines/teapot/index.js

@@ -0,0 +1,167 @@
+"use strict";
+var TeapotEngine_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk = require("chalk");
+const inversify_1 = require("inversify");
+const commons_1 = require("@expressive-tea/commons");
+const commons_2 = require("@expressive-tea/commons");
+const ProxyRoute_1 = require("../../classes/ProxyRoute");
+const Engine_1 = require("../../classes/Engine");
+const teapot_helper_1 = require("../../helpers/teapot-helper");
+const constants_1 = require("../constants/constants");
+const commons_3 = require("@expressive-tea/commons");
+let TeapotEngine = TeapotEngine_1 = class TeapotEngine extends Engine_1.default {
+    constructor() {
+        super(...arguments);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.clients = new Map();
+        this.registeredRoute = new Map();
+        this.isStopped = false;
+    }
+    static header(teapotSettings) {
+        console.log(chalk.white.bold('Teapot Engine is initializing...'));
+        console.log(chalk `
+             {white.bold ;,'}
+     {green _o_}    {white.bold ;:;'}
+ {blue.bold ,-.}{green '---\`}{blue.bold .__} {white.bold ; }
+{blue.bold ((j\`=====',-'}
+ {blue.bold \`-\\     /}
+    {blue.bold \`-=-'}
+
+{white Please assign the next} {white.bold Client Key:} {magenta.bold ${teapotSettings.clientKey}} {white to all your}
+{yellow.bold Teacups} {white and do not share the key with anyone}
+
+{yellow.bold NOTICE:}
+All Communication are encrypted to ensure intruder can not connected, however, please does not share any sensitive data like keys or passwords to avoid security issues.
+  `);
+    }
+    registerTeacup(teacup) {
+        console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}]: {grey.bold Connected}`);
+        teacup.emit('handshake', Buffer.from(this.publicKey), this.serverSignature, Boolean(this.serverSecure), this.clientVerification.bind(this, teacup));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        teacup.on('disconnect', this.disconnected.bind(this, teacup));
+    }
+    clientVerification(teacup, userPublicKey, userSignature) {
+        console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}]: {yellow.bold Client Verification Started}`);
+        try {
+            if (!teapot_helper_1.default.verify(this.teapotSettings.clientKey, userPublicKey.toString('ascii'), userSignature)) {
+                console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP} [{magenta.bold ${teacup.id}}]: Failed to verify and will be disconnected...`);
+                return teacup.disconnect();
+            }
+            this.clients.set(teacup.id, {
+                publicKey: userPublicKey,
+                signature: userSignature
+            });
+            teacup.emit('accepted', this.registered.bind(this, teacup));
+            console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}]: {green.bold Client Verified}`);
+        }
+        catch (e) {
+            const error = e;
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP} [{magenta.bold ${teacup.id}}]: Failed wiht next message: ${error.message}`);
+            teacup.disconnect();
+        }
+    }
+    registered(teacup, encryptedMessage) {
+        try {
+            const message = teapot_helper_1.default.decrypt(encryptedMessage, this.serverSignature);
+            const isRegistered = this.registeredRoute.has(message.mountTo);
+            const proxyRoute = isRegistered ? this.registeredRoute.get(message.mountTo) : new ProxyRoute_1.default(message.mountTo);
+            if (!proxyRoute) {
+                throw new Error('Failed to create or retrieve proxy route');
+            }
+            proxyRoute.registerServer(message.address, teacup.id);
+            if (!isRegistered) {
+                this.registeredRoute.set(message.mountTo, proxyRoute);
+                this.context.getApplication().use(message.mountTo, teapot_helper_1.default.proxyResponse.bind(this, proxyRoute));
+            }
+            console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}] {blue.bold <${message.address}>} <--> {white.bold ${message.mountTo}}`);
+        }
+        catch (e) {
+            const error = e;
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP}  {magenta.bold ${teacup.id}}: Failed wiht next message: ${error.message}`);
+        }
+    }
+    removeFromRoutes(routes = [], id) {
+        routes.forEach(route => {
+            const proxyRoute = this.registeredRoute.get(route);
+            if (proxyRoute) {
+                proxyRoute.unregisterServer(id);
+            }
+        });
+    }
+    findClientInRoutes(teacupId) {
+        const routes = [];
+        this.registeredRoute.forEach((proxyRoute, route) => {
+            if (proxyRoute.isClientOnRoute(teacupId)) {
+                routes.push(route);
+            }
+        });
+        return routes;
+    }
+    disconnected(teacup, reason) {
+        try {
+            const routes = this.findClientInRoutes(teacup.id);
+            this.removeFromRoutes(routes, teacup.id);
+            console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}]: Got disconnected by ${reason}`);
+        }
+        catch (e) {
+            const error = e;
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP}  {magenta.bold ${teacup.id}}: Failed wiht next message: ${error.message}`);
+        }
+    }
+    async init() {
+        // Metadata is stored on the class by decorators, not on instances
+        this.teapotSettings = commons_1.Metadata.get(commons_2.ASSIGN_TEAPOT_KEY, (0, commons_3.getClass)(this.context));
+        const { publicKey, privateKey } = teapot_helper_1.default.generateKeys(this.teapotSettings.serverKey);
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
+        this.serverSignature = teapot_helper_1.default.sign(this.teapotSettings.clientKey, privateKey, this.teapotSettings.serverKey);
+    }
+    async start() {
+        // Socket.IO instance is stored on the Boot instance at runtime (not on the class)
+        this.socketServer = commons_1.Metadata.get(constants_1.SOCKET_IO_INSTANCE_KEY, this.context).of('/teapot');
+        TeapotEngine_1.header(this.teapotSettings);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        this.socketServer.on('connection', this.registerTeacup.bind(this));
+    }
+    /**
+     * Graceful shutdown for the Teapot engine.
+     *
+     * Disconnects all connected Teacup clients, closes the Socket.IO namespace,
+     * and clears internal state. This method is idempotent and safe to call multiple times.
+     *
+     * @returns {Promise<void>} Promise that resolves when cleanup is complete
+     * @since 2.0.0
+     */
+    async stop() {
+        // Idempotent: skip if already stopped or never started
+        if (this.isStopped || !this.socketServer) {
+            return;
+        }
+        this.isStopped = true;
+        console.log(chalk.cyan.bold('[TEAPOT]') + ' - Initiating graceful shutdown...');
+        // Disconnect all connected clients gracefully
+        const connectedSockets = await this.socketServer.fetchSockets();
+        for (const socket of connectedSockets) {
+            const routes = this.findClientInRoutes(socket.id);
+            this.removeFromRoutes(routes, socket.id);
+            socket.disconnect(true);
+            console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${socket.id}}]: {yellow.bold Disconnected for shutdown}`);
+        }
+        // Remove all listeners from the namespace
+        this.socketServer.removeAllListeners();
+        // Clear internal state
+        this.clients.clear();
+        this.registeredRoute.clear();
+        console.log(chalk.cyan.bold('[TEAPOT]') + ' - Graceful shutdown complete.');
+    }
+    static canRegister(ctx) {
+        return commons_1.Metadata.get(commons_2.ASSIGN_TEAPOT_KEY, (0, commons_3.getClass)(ctx), 'isTeapotActive');
+    }
+};
+TeapotEngine = TeapotEngine_1 = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    (0, inversify_1.injectFromBase)({ extendConstructorArguments: true })
+], TeapotEngine);
+exports.default = TeapotEngine;

package/engines/websocket/index.d.ts

@@ -0,0 +1,9 @@
+import ExpressiveTeaEngine from '../../classes/Engine';
+import Boot from '../../classes/Boot';
+import Settings from '../../classes/Settings';
+export default class WebsocketEngine extends ExpressiveTeaEngine {
+    canStart: boolean;
+    isDetached: boolean;
+    init(): void;
+    static canRegister(ctx?: Boot, settings?: Settings): boolean;
+}

package/engines/websocket/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const WebsocketService_1 = require("../../services/WebsocketService");
+const WebSocket = require("ws");
+const inversify_1 = require("inversify");
+const Engine_1 = require("../../classes/Engine");
+let WebsocketEngine = class WebsocketEngine extends Engine_1.default {
+    constructor() {
+        super(...arguments);
+        this.canStart = false;
+        this.isDetached = false;
+    }
+    init() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        this.canStart = this.settings.get('startWebsocket');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        this.isDetached = this.settings.get('detachWebsocket');
+        if (this.canStart) {
+            WebsocketService_1.default.init();
+            WebsocketService_1.default.getInstance().setWebSocket(new WebSocket.Server(this.isDetached ? { noServer: true } : { server: this.server }));
+            if (this.serverSecure) {
+                WebsocketService_1.default.getInstance().setSecureWebsocket(new WebSocket.Server(this.isDetached ? { noServer: true } : { server: this.serverSecure }));
+            }
+            WebsocketService_1.default.getInstance().setHttpServer(this.server);
+            WebsocketService_1.default.getInstance().setHttpServer(this.serverSecure);
+        }
+    }
+    static canRegister(ctx, settings) {
+        var _a;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return (_a = settings === null || settings === void 0 ? void 0 : settings.get('startWebsocket')) !== null && _a !== void 0 ? _a : false;
+    }
+};
+WebsocketEngine = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    (0, inversify_1.injectFromBase)({ extendConstructorArguments: true })
+], WebsocketEngine);
+exports.default = WebsocketEngine;

package/eslint.config.mjs

@@ -0,0 +1,138 @@
+// @ts-check
+import eslint from '@eslint/js';
+import tseslintPlugin from '@typescript-eslint/eslint-plugin';
+import tsparser from '@typescript-eslint/parser';
+import jsdoc from 'eslint-plugin-jsdoc';
+import globals from 'globals';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export default [
+  // Global ignores (applies to all configs)
+  {
+    ignores: [
+      'benchmark/**',
+      '__test__/mock/*',
+      '__test__/**/helper/*',
+      'node_modules/**',
+      'coverage/**',
+      'dist/**',
+      '**/*.js',
+      '**/*.d.ts',
+      '**/*.js.map',
+      '**/*.d.ts.map',
+      '!eslint.config.js',
+      '!jest.config.js',
+      '!gulpfile.js',
+    ],
+  },
+  
+  // Base ESLint recommended rules
+  eslint.configs.recommended,
+  
+  // Main configuration for TypeScript files
+  {
+    files: ['**/*.ts'],
+    languageOptions: {
+      parser: tsparser,
+      parserOptions: {
+        project: './tsconfig.linter.json',
+        tsconfigRootDir: __dirname,
+      },
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+        ...globals.es2021,
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tseslintPlugin,
+      jsdoc,
+    },
+    rules: {
+      // Apply TypeScript recommended rules
+      ...tseslintPlugin.configs.recommended.rules,
+      
+      // Disable semicolon requirements
+      'semi': 'off',
+      '@typescript-eslint/semi': 'off',
+      
+      // Array type preferences
+      '@typescript-eslint/array-type': ['error', { default: 'array' }],
+      
+      // Return await handling
+      '@typescript-eslint/return-await': 'off',
+      
+      // Boolean expression strictness
+      '@typescript-eslint/strict-boolean-expressions': 'off',
+      
+      // Function return type requirements
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      
+      // Allow classes with only static members
+      '@typescript-eslint/no-extraneous-class': 'off',
+      
+      // Unsafe argument warnings
+      '@typescript-eslint/no-unsafe-argument': 'warn',
+      '@typescript-eslint/no-unsafe-assignment': 'warn',
+      '@typescript-eslint/no-unsafe-member-access': 'warn',
+      '@typescript-eslint/no-unsafe-call': 'warn',
+      '@typescript-eslint/no-unsafe-return': 'warn',
+      
+      // Unused variables with ignore patterns
+      '@typescript-eslint/no-unused-vars': ['error', { 
+        argsIgnorePattern: '^_',
+        varsIgnorePattern: '^_',
+      }],
+      
+      // Allow explicit any where needed (warn instead of error)
+      '@typescript-eslint/no-explicit-any': 'warn',
+      
+      // Allow non-null assertions (used in tests)
+      '@typescript-eslint/no-non-null-assertion': 'off',
+      
+      // Allow require imports (used in some configs)
+      '@typescript-eslint/no-require-imports': 'off',
+      
+      // General rules
+      'no-duplicate-imports': 'off',
+      'no-unused-vars': 'off', // Use TypeScript version instead
+    },
+  },
+  
+  // Configuration for test files
+  {
+    files: ['__test__/**/*.ts', '**/*.spec.ts', '**/*.test.ts'],
+    languageOptions: {
+      globals: {
+        ...globals.jest,
+      },
+    },
+    rules: {
+      // Relax TypeScript strict rules for test files
+      '@typescript-eslint/no-unsafe-argument': 'off',
+      '@typescript-eslint/no-unsafe-assignment': 'off',
+      '@typescript-eslint/no-unsafe-member-access': 'off',
+      '@typescript-eslint/no-unsafe-call': 'off',
+      '@typescript-eslint/no-unsafe-return': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+    },
+  },
+  
+  // Configuration for JavaScript config files
+  {
+    files: ['*.js', '*.mjs', '*.cjs'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-require-imports': 'off',
+    },
+  },
+];
+

package/exceptions/BootLoaderExceptions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @namespace Exceptions
+ */
+/**
+ * Exception Class for Hard Required Plugins.
+ * This Exception is used internally to describe when a required plugin fails, is the server returns this
+ * is meaning a module fails and the application it wont start since the plugin is marked as hard require to initialize
+ * the application.
+ * @export
+ * @class BootLoaderRequiredExceptions
+ * @extends {Error}
+ * @summary Required Module Exception
+ */
+export declare class BootLoaderRequiredExceptions extends Error {
+}
+/**
+ * Exception Class for Soft Required Plugins
+ * This Exception is used internally to describe when a required plugin fails but allow to continue running
+ * the application and it means that plugin fails to initialize but is not critical to the app.
+ * @export
+ * @class BootLoaderSoftExceptions
+ * @extends {Error}
+ * @summary Not Required Plugin Exception
+ */
+export declare class BootLoaderSoftExceptions extends Error {
+}

package/exceptions/BootLoaderExceptions.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BootLoaderSoftExceptions = exports.BootLoaderRequiredExceptions = void 0;
+/**
+ * @namespace Exceptions
+ */
+/**
+ * Exception Class for Hard Required Plugins.
+ * This Exception is used internally to describe when a required plugin fails, is the server returns this
+ * is meaning a module fails and the application it wont start since the plugin is marked as hard require to initialize
+ * the application.
+ * @export
+ * @class BootLoaderRequiredExceptions
+ * @extends {Error}
+ * @summary Required Module Exception
+ */
+class BootLoaderRequiredExceptions extends Error {
+}
+exports.BootLoaderRequiredExceptions = BootLoaderRequiredExceptions;
+/**
+ * Exception Class for Soft Required Plugins
+ * This Exception is used internally to describe when a required plugin fails but allow to continue running
+ * the application and it means that plugin fails to initialize but is not critical to the app.
+ * @export
+ * @class BootLoaderSoftExceptions
+ * @extends {Error}
+ * @summary Not Required Plugin Exception
+ */
+class BootLoaderSoftExceptions extends Error {
+}
+exports.BootLoaderSoftExceptions = BootLoaderSoftExceptions;

package/exceptions/RequestExceptions.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @namespace Exceptions
+ */
+/**
+ * HTTP Generic Exception Use this Exception to easily return a HTTP Error on the endpoints handlers.
+ * @export
+ * @class GenericRequestException
+ * @extends {Error}
+ * @param {string} message='Server Error' Provide the Error message.
+ * @param {number} [statusCode=500] HTTP Response Code
+ * @summary HTTP Exception Helper
+ * @example
+ * {REPLACE-AT}Router('/')
+ * class ExceptionExampleController {
+ *   {REPLACE-AT}Get('/exception')
+ *   exceptionMethod(req, res, next) {
+ *     try {
+ *       throw new GenericRequestException('Page not found', 404);
+ *     } catch (e) {
+ *       res.status(e.code).send(e.message);
+ *     }
+ *   }
+ * }
+ */
+export declare class GenericRequestException extends Error {
+    statusCode: number;
+    message: string;
+    constructor(message: string, statusCode?: number);
+}
+/**
+ * Shortcut Exception for 400 HTTP Errors (Bad Request).
+ * @export
+ * @class BadRequestException
+ * @extends {GenericRequestException}
+ * @param {string} [message='Bad Request'] Provide the Error message.
+ * @summary 400 Exception
+ * @example
+ * {REPLACE-AT}Router('/')
+ * class ExceptionExampleController {
+ *   {REPLACE-AT}Get('/exception')
+ *   exceptionMethod(req, res, next) {
+ *     try {
+ *       throw new BadRequestException();
+ *     } catch (e) {
+ *       res.status(e.code).send(e.message);
+ *     }
+ *   }
+ * }
+ */
+export declare class BadRequestException extends GenericRequestException {
+    constructor(message?: string);
+}
+/**
+ * Shortcut Exception for 401 HTTP Errors (Unauthorized Request).
+ * @export
+ * @class UnauthorizedException
+ * @extends {GenericRequestException}
+ * @param {string} [message='Unauthorized Request'] Provide the Error message.
+ * @summary 401 Exception
+ * @example
+ * {REPLACE-AT}Router('/')
+ * class ExceptionExampleController {
+ *   {REPLACE-AT}Get('/exception')
+ *   exceptionMethod(req, res, next) {
+ *     try {
+ *       throw new UnauthorizedException();
+ *     } catch (e) {
+ *       res.status(e.code).send(e.message);
+ *     }
+ *   }
+ * }
+ */
+export declare class UnauthorizedException extends GenericRequestException {
+    constructor(message?: string);
+}