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

package/engines/index.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Core Engine Registration
+ *
+ * Automatically registers all core Expressive Tea engines with the EngineRegistry.
+ * Import this file to enable all core engines with proper dependency order.
+ *
+ * Engine Priority Order:
+ * - 0: HTTPEngine (base engine, no dependencies)
+ * - 5: HealthCheckEngine (health endpoints, depends on http)
+ * - 10: SocketIOEngine, WebsocketEngine (depend on http)
+ * - 20: TeapotEngine, TeacupEngine (depend on http, socketio)
+ *
+ * @example
+ * ```typescript
+ * import '@expressive-tea/core/engines'; // Registers all core engines
+ * import Boot from '@expressive-tea/core';
+ *
+ * class MyApp extends Boot {}
+ * ```
+ *
+ * @module engines
+ * @since 2.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeacupEngine = exports.TeapotEngine = exports.WebsocketEngine = exports.SocketIOEngine = exports.HealthCheckEngine = exports.HTTPEngine = void 0;
+const EngineRegistry_1 = require("../classes/EngineRegistry");
+const http_1 = require("./http");
+exports.HTTPEngine = http_1.default;
+const health_1 = require("./health");
+exports.HealthCheckEngine = health_1.default;
+const socketio_1 = require("./socketio");
+exports.SocketIOEngine = socketio_1.default;
+const websocket_1 = require("./websocket");
+exports.WebsocketEngine = websocket_1.default;
+const teapot_1 = require("./teapot");
+exports.TeapotEngine = teapot_1.default;
+const teacup_1 = require("./teacup");
+exports.TeacupEngine = teacup_1.default;
+/**
+ * Register HTTP Engine
+ * Priority: 0 (runs first)
+ * Dependencies: none
+ */
+EngineRegistry_1.default.register({
+    engine: http_1.default,
+    name: 'http',
+    version: '2.0.0',
+    priority: 0,
+    dependencies: []
+});
+/**
+ * Register Health Check Engine
+ * Priority: 5
+ * Dependencies: http (needs HTTP server for endpoints)
+ */
+EngineRegistry_1.default.register({
+    engine: health_1.default,
+    name: 'health',
+    version: '2.0.0',
+    priority: 5,
+    dependencies: ['http']
+});
+/**
+ * Register SocketIO Engine
+ * Priority: 10
+ * Dependencies: http (needs HTTP server to attach to)
+ */
+EngineRegistry_1.default.register({
+    engine: socketio_1.default,
+    name: 'socketio',
+    version: '2.0.0',
+    priority: 10,
+    dependencies: ['http']
+});
+/**
+ * Register Websocket Engine
+ * Priority: 10
+ * Dependencies: http (needs HTTP server to attach to)
+ */
+EngineRegistry_1.default.register({
+    engine: websocket_1.default,
+    name: 'websocket',
+    version: '2.0.0',
+    priority: 10,
+    dependencies: ['http']
+});
+/**
+ * Register Teapot Engine (Microservice Gateway Server)
+ * Priority: 20
+ * Dependencies: http, socketio
+ */
+EngineRegistry_1.default.register({
+    engine: teapot_1.default,
+    name: 'teapot',
+    version: '2.0.0',
+    priority: 20,
+    dependencies: ['http', 'socketio']
+});
+/**
+ * Register Teacup Engine (Microservice Gateway Client)
+ * Priority: 20
+ * Dependencies: http, socketio
+ */
+EngineRegistry_1.default.register({
+    engine: teacup_1.default,
+    name: 'teacup',
+    version: '2.0.0',
+    priority: 20,
+    dependencies: ['http', 'socketio']
+});
+exports.default = EngineRegistry_1.default;

package/engines/socketio/index.d.ts

@@ -2,5 +2,6 @@ import ExpressiveTeaEngine from '../../classes/Engine';
 export default class SocketIOEngine extends ExpressiveTeaEngine {
     private io;
     private ioSecure;
-    init(): Promise<void>;
+    init(): void;
+    static canRegister(): boolean;
 }

package/engines/socketio/index.js

@@ -1,20 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const socket_io_1 = require("socket.io");
+const inversify_1 = require("inversify");
 const Engine_1 = require("../../classes/Engine");
-const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
+const commons_1 = require("@expressive-tea/commons");
 const constants_1 = require("../constants/constants");
-class SocketIOEngine extends Engine_1.default {
-    async init() {
+let SocketIOEngine = class SocketIOEngine extends Engine_1.default {
+    init() {
         const commonConfig = {
             path: '/exp-tea/',
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             transports: ['websocket', 'polling']
         };
         this.io = this.server && new socket_io_1.Server(this.server, Object.assign({}, commonConfig));
         this.ioSecure = this.serverSecure && new socket_io_1.Server(this.serverSecure, Object.assign({}, commonConfig));
-        Metadata_1.default.set(constants_1.SOCKET_IO_INSTANCE_KEY, this.io, this.context);
-        Metadata_1.default.set(constants_1.SOCKET_IO_SECURE_INSTANCE_KEY, this.ioSecure, this.context);
+        commons_1.Metadata.set(constants_1.SOCKET_IO_INSTANCE_KEY, this.io, this.context);
+        commons_1.Metadata.set(constants_1.SOCKET_IO_SECURE_INSTANCE_KEY, this.ioSecure, this.context);
     }
-}
+    static canRegister() {
+        return true;
+    }
+};
+SocketIOEngine = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    (0, inversify_1.injectFromBase)({ extendConstructorArguments: true })
+], SocketIOEngine);
 exports.default = SocketIOEngine;
 ;

package/engines/teacup/index.d.ts

@@ -1,4 +1,5 @@
 import ExpressiveTeaEngine from '../../classes/Engine';
+import Boot from '../../classes/Boot';
 export default class TeacupEngine extends ExpressiveTeaEngine {
     private teacupSettings;
     private publicKey;
@@ -7,8 +8,20 @@ export default class TeacupEngine extends ExpressiveTeaEngine {
     private serverSignature;
     private clientSignature;
     private client;
+    private isStopping;
     private header;
     private handshaked;
     private accepted;
     start(): Promise<void>;
+    static canRegister(ctx?: Boot): boolean;
+    /**
+     * 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
+     */
+    stop(): Promise<void>;
 }

package/engines/teacup/index.js

@@ -1,17 +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 = require("url");
-// tslint:disable-next-line:no-duplicate-imports
+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 `
@@ -26,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}`);
@@ -38,31 +43,34 @@ 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));
-        const scheme = url.parse(this.teacupSettings.serverUrl);
+        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;
@@ -74,13 +82,55 @@ All Communication are encrypted to ensure intruder can not connected, however, p
             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.injectable)(),
+    (0, inversify_1.injectFromBase)({ extendConstructorArguments: true })
 ], TeacupEngine);
 exports.default = TeacupEngine;

package/engines/teapot/index.d.ts

@@ -1,12 +1,14 @@
 import ExpressiveTeaEngine from '../../classes/Engine';
+import Boot from '../../classes/Boot';
 export default class TeapotEngine extends ExpressiveTeaEngine {
-    private clients;
-    private registeredRoute;
+    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;
@@ -16,4 +18,15 @@ export default class TeapotEngine extends ExpressiveTeaEngine {
     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

@@ -4,17 +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 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...'));
@@ -36,12 +39,11 @@ All Communication are encrypted to ensure intruder can not connected, however, p
     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}`);
-        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...`);
@@ -55,15 +57,19 @@ 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);
@@ -72,13 +78,16 @@ All Communication are encrypted to ensure intruder can not connected, however, p
             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) {
@@ -97,23 +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));
     }
+    /**
+     * 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

@@ -1,6 +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(): 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();
@@ -24,8 +26,14 @@ let WebsocketEngine = class WebsocketEngine extends Engine_1.default {
             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.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',
+    },
+  },
+];
+