@zerooneit/expressive-tea 1.3.0-beta.6 → 2.0.0

package/engines/teacup/index.js

@@ -1,16 +1,21 @@
 "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 Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
-const constants_1 = require("@expressive-tea/commons/constants");
+const commons_1 = require("@expressive-tea/commons");
+const commons_2 = require("@expressive-tea/commons");
 const teapot_helper_1 = require("../../helpers/teapot-helper");
-const object_helper_1 = require("@expressive-tea/commons/helpers/object-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 `
@@ -25,6 +30,7 @@ let TeacupEngine = class TeacupEngine extends Engine_1.default {
 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}`);
@@ -37,30 +43,33 @@ All Communication are encrypted to ensure intruder can not connected, however, p
             cb(Buffer.from(this.publicKey), this.clientSignature);
         }
         catch (e) {
-            console.error(chalk `{cyan.bold [TEACUP]} - {red.bold TEAPOD}  {magenta.bold ${this.client.id}}: Failed with next message: ${e.message}`);
+            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.slice(0, 32));
+        }, this.serverSignature);
         cb(encryptedMessage);
         const onClose = () => {
             try {
                 this.client.close();
             }
-            catch (_) {
+            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 = Metadata_1.default.get(constants_1.ASSIGN_TEACUP_KEY, (0, object_helper_1.getClass)(this.context));
+        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);
@@ -80,11 +89,48 @@ All Communication are encrypted to ensure intruder can not connected, however, p
         this.client.on('error', console.log);
         this.client.connect();
     }
-    static canRegister(ctx, settings) {
-        return Metadata_1.default.get(constants_1.ASSIGN_TEACUP_KEY, (0, object_helper_1.getClass)(ctx), 'isTeacupActive');
+    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.injectable)(),
+    (0, inversify_1.injectFromBase)({ extendConstructorArguments: true })
 ], TeacupEngine);
 exports.default = TeacupEngine;

package/engines/teapot/index.d.ts

@@ -1,6 +1,5 @@
 import ExpressiveTeaEngine from '../../classes/Engine';
 import Boot from '../../classes/Boot';
-import Settings from '../../classes/Settings';
 export default class TeapotEngine extends ExpressiveTeaEngine {
     private readonly clients;
     private readonly registeredRoute;
@@ -9,6 +8,7 @@ export default class TeapotEngine extends ExpressiveTeaEngine {
     private privateKey;
     private serverSignature;
     private socketServer;
+    private isStopped;
     private static header;
     private registerTeacup;
     private clientVerification;
@@ -18,5 +18,15 @@ export default class TeapotEngine extends ExpressiveTeaEngine {
     private disconnected;
     init(): Promise<void>;
     start(): Promise<void>;
-    static canRegister(ctx?: Boot, settings?: Settings): boolean;
+    /**
+     * 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

@@ -4,18 +4,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const chalk = require("chalk");
 const inversify_1 = require("inversify");
-const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
-const constants_1 = require("@expressive-tea/commons/constants");
+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_2 = require("../constants/constants");
-const object_helper_1 = require("@expressive-tea/commons/helpers/object-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...'));
@@ -42,8 +44,6 @@ All Communication are encrypted to ensure intruder can not connected, however, p
     }
     clientVerification(teacup, userPublicKey, userSignature) {
         console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}]: {yellow.bold Client Verification Started}`);
-        console.log('userKey', userPublicKey.toString('base64'));
-        console.log('userSignature', userSignature.toString('base64'));
         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...`);
@@ -57,31 +57,37 @@ All Communication are encrypted to ensure intruder can not connected, however, p
             console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}]: {green.bold Client Verified}`);
         }
         catch (e) {
-            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP} [{magenta.bold ${teacup.id}}]: Failed wiht next message: ${e.message}`);
+            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.slice(0, 32));
+            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);
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 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) {
-            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP}  {magenta.bold ${teacup.id}}: Failed wiht next message: ${e.message}`);
+            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);
-            proxyRoute.unregisterServer(id);
+            if (proxyRoute) {
+                proxyRoute.unregisterServer(id);
+            }
         });
     }
     findClientInRoutes(teacupId) {
@@ -100,27 +106,62 @@ All Communication are encrypted to ensure intruder can not connected, however, p
             console.log(chalk `{cyan.bold [TEAPOT]} - {blue TEACUP} [{magenta.bold ${teacup.id}}]: Got disconnected by ${reason}`);
         }
         catch (e) {
-            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP}  {magenta.bold ${teacup.id}}: Failed wiht next message: ${e.message}`);
+            const error = e;
+            console.log(chalk `{cyan.bold [TEAPOT]} - {red.bold TEACUP}  {magenta.bold ${teacup.id}}: Failed wiht next message: ${error.message}`);
         }
     }
     async init() {
-        this.teapotSettings = Metadata_1.default.get(constants_1.ASSIGN_TEAPOT_KEY, this.context);
+        // 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() {
-        this.socketServer = Metadata_1.default.get(constants_2.SOCKET_IO_INSTANCE_KEY, this.context).of('/teapot');
+        // 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));
     }
-    static canRegister(ctx, settings) {
-        return Metadata_1.default.get(constants_1.ASSIGN_TEAPOT_KEY, (0, object_helper_1.getClass)(ctx), 'isTeapotActive');
+    /**
+     * 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.injectable)(),
+    (0, inversify_1.injectFromBase)({ extendConstructorArguments: true })
 ], TeapotEngine);
 exports.default = TeapotEngine;

package/engines/websocket/index.d.ts

@@ -4,6 +4,6 @@ import Settings from '../../classes/Settings';
 export default class WebsocketEngine extends ExpressiveTeaEngine {
     canStart: boolean;
     isDetached: boolean;
-    init(): Promise<void>;
+    init(): void;
     static canRegister(ctx?: Boot, settings?: Settings): boolean;
 }

package/engines/websocket/index.js

@@ -11,8 +11,10 @@ let WebsocketEngine = class WebsocketEngine extends Engine_1.default {
         this.canStart = false;
         this.isDetached = false;
     }
-    async init() {
+    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();
@@ -25,10 +27,13 @@ let WebsocketEngine = class WebsocketEngine extends Engine_1.default {
         }
     }
     static canRegister(ctx, settings) {
-        return settings.get('startWebsocket');
+        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.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/RequestExceptions.d.ts

@@ -25,7 +25,7 @@
 export declare class GenericRequestException extends Error {
     statusCode: number;
     message: string;
-    constructor(message: string | never, statusCode?: number);
+    constructor(message: string, statusCode?: number);
 }
 /**
  * Shortcut Exception for 400 HTTP Errors (Bad Request).
@@ -48,7 +48,7 @@ export declare class GenericRequestException extends Error {
  * }
  */
 export declare class BadRequestException extends GenericRequestException {
-    constructor(message?: string | never);
+    constructor(message?: string);
 }
 /**
  * Shortcut Exception for 401 HTTP Errors (Unauthorized Request).
@@ -71,5 +71,5 @@ export declare class BadRequestException extends GenericRequestException {
  * }
  */
 export declare class UnauthorizedException extends GenericRequestException {
-    constructor(message?: string | never);
+    constructor(message?: string);
 }

package/helpers/boot-helper.d.ts

@@ -1,7 +1,7 @@
-import { BOOT_STAGES } from '@expressive-tea/commons/constants';
+import { BOOT_STAGES } from '@expressive-tea/commons';
 import { type Express } from 'express';
 import type Boot from '../classes/Boot';
 export declare function resolveStage(stage: BOOT_STAGES, ctx: Boot, server: Express, ...extraArgs: unknown[]): Promise<void>;
-export declare function resolveDirectives(instance: typeof Boot | Boot, server: Express): Promise<void>;
-export declare function resolveStatic(instance: typeof Boot | Boot, server: Express): Promise<void>;
-export declare function resolveProxy(ProxyContainer: any, server: Express): Promise<void>;
+export declare function resolveDirectives(instance: typeof Boot | Boot, server: Express): void;
+export declare function resolveStatic(instance: typeof Boot | Boot, server: Express): void;
+export declare function resolveProxy(ProxyContainer: any, server: Express): void;

package/helpers/boot-helper.js

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveProxy = exports.resolveStatic = exports.resolveDirectives = exports.resolveStage = void 0;
-const constants_1 = require("@expressive-tea/commons/constants");
+exports.resolveStage = resolveStage;
+exports.resolveDirectives = resolveDirectives;
+exports.resolveStatic = resolveStatic;
+exports.resolveProxy = resolveProxy;
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return */
+const commons_1 = require("@expressive-tea/commons");
 const express = require("express");
-const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
-const object_helper_1 = require("@expressive-tea/commons/helpers/object-helper");
+const commons_2 = require("@expressive-tea/commons");
+const commons_3 = require("@expressive-tea/commons");
 const BootLoaderExceptions_1 = require("../exceptions/BootLoaderExceptions");
+const DependencyInjection_1 = require("../services/DependencyInjection");
 async function resolveStage(stage, ctx, server, ...extraArgs) {
     try {
         await bootloaderResolve(stage, server, ctx, ...extraArgs);
-        if (stage === constants_1.BOOT_STAGES.APPLICATION) {
-            await resolveModules(ctx, server);
+        if (stage === commons_1.BOOT_STAGES.APPLICATION) {
+            resolveModules(ctx, server);
         }
     }
     catch (e) {
@@ -19,18 +24,16 @@ async function resolveStage(stage, ctx, server, ...extraArgs) {
         }
     }
 }
-exports.resolveStage = resolveStage;
-async function resolveDirectives(instance, server) {
-    const registeredDirectives = Metadata_1.default.get(constants_1.REGISTERED_DIRECTIVES_KEY, (0, object_helper_1.getClass)(instance)) || [];
+function resolveDirectives(instance, server) {
+    const registeredDirectives = commons_2.Metadata.get(commons_1.REGISTERED_DIRECTIVES_KEY, (0, commons_3.getClass)(instance)) || [];
     registeredDirectives.forEach((options) => {
         // @ts-expect-error Settings can be any parameter
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         server.set(options.name, ...options.settings);
     });
 }
-exports.resolveDirectives = resolveDirectives;
-async function resolveStatic(instance, server) {
-    const registeredStatic = Metadata_1.default.get(constants_1.REGISTERED_STATIC_KEY, (0, object_helper_1.getClass)(instance)) || [];
+function resolveStatic(instance, server) {
+    const registeredStatic = commons_2.Metadata.get(commons_1.REGISTERED_STATIC_KEY, (0, commons_3.getClass)(instance)) || [];
     registeredStatic.forEach((staticOptions) => {
         if (staticOptions.virtual) {
             server.use(staticOptions.virtual, express.static(staticOptions.root, staticOptions.options));
@@ -40,21 +43,23 @@ async function resolveStatic(instance, server) {
         }
     });
 }
-exports.resolveStatic = resolveStatic;
-async function resolveProxy(ProxyContainer, server) {
+function resolveProxy(ProxyContainer, server) {
     const proxyContainer = new ProxyContainer();
     proxyContainer.__register(server);
 }
-exports.resolveProxy = resolveProxy;
-async function resolveModules(instance, server) {
-    const registeredModules = Metadata_1.default.get(constants_1.REGISTERED_MODULE_KEY, instance, 'start') || [];
-    registeredModules.forEach(Module => {
-        const moduleInstance = new Module();
+function resolveModules(instance, server) {
+    // Metadata is stored on the class by decorators, so we need to get the constructor
+    // If instance is already a class (typeof === 'function'), use it directly
+    // If instance is an object, get its constructor
+    const target = typeof instance === 'function' ? instance : instance.constructor;
+    const registeredModules = commons_2.Metadata.get(commons_1.REGISTERED_MODULE_KEY, target, 'start') || [];
+    for (const Module of registeredModules) {
+        const moduleInstance = (0, DependencyInjection_1.getInstanceOf)(Module);
         moduleInstance.__register(server);
-    });
+    }
 }
 async function bootloaderResolve(STAGE, server, instance, ...args) {
-    const bootLoader = Metadata_1.default.get(constants_1.BOOT_STAGES_KEY, (0, object_helper_1.getClass)(instance)) || constants_1.STAGES_INIT;
+    const bootLoader = commons_2.Metadata.get(commons_1.BOOT_STAGES_KEY, (0, commons_3.getClass)(instance)) || commons_1.STAGES_INIT;
     for (const loader of bootLoader[STAGE] || []) {
         try {
             await selectLoaderType(loader, server, ...args);
@@ -64,7 +69,7 @@ async function bootloaderResolve(STAGE, server, instance, ...args) {
         }
     }
 }
-async function selectLoaderType(loader, server, ...args) {
+function selectLoaderType(loader, server, ...args) {
     return loader.method(server, ...args);
 }
 function checkIfStageFails(e) {

package/helpers/decorators.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addAnnotation = void 0;
-const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
-const constants_1 = require("@expressive-tea/commons/constants");
+exports.addAnnotation = addAnnotation;
+const commons_1 = require("@expressive-tea/commons");
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+const commons_2 = require("@expressive-tea/commons");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function addAnnotation(type, target, propertyKey, ...args) {
-    const annotations = Metadata_1.default.get(constants_1.ROUTER_ANNOTATIONS_KEY, target, propertyKey) || [];
+    const annotations = commons_1.Metadata.get(commons_2.ROUTER_ANNOTATIONS_KEY, target, propertyKey) || [];
     annotations.unshift({
         arguments: args,
         type
     });
-    Metadata_1.default.set(constants_1.ROUTER_ANNOTATIONS_KEY, annotations, target, propertyKey);
+    commons_1.Metadata.set(commons_2.ROUTER_ANNOTATIONS_KEY, annotations, target, propertyKey);
 }
-exports.addAnnotation = addAnnotation;

package/helpers/promise-helper.d.ts

@@ -1 +1 @@
-export declare function delay(ms: number): Promise<unknown>;
+export declare function delay(ms: number): Promise<void>;

package/helpers/promise-helper.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.delay = void 0;
+exports.delay = delay;
 async function delay(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
-exports.delay = delay;