@expressive-tea/core 2.0.0

package/mixins/route.d.ts

@@ -0,0 +1,48 @@
+import { type Constructor } from '../types/core';
+import type { ExpressiveTeaHandlerOptions } from '@expressive-tea/commons';
+import { Router } from 'express';
+import type { ExpressMiddlewareHandler } from '@expressive-tea/commons';
+/**
+ * Type definition for a routerized class
+ * Represents a class that has been enhanced with Expressive Tea route capabilities
+ * @template TBase - The base constructor type being extended
+ * @since 2.0.0
+ */
+export type RouterizedClass<TBase extends Constructor> = TBase & (new (...args: any[]) => {
+    /** Express router for this route controller */
+    readonly router: Router;
+    /** Mountpoint path for this controller */
+    readonly mountpoint: string;
+    /** Mount this controller's router on a parent router */
+    __mount(parent: Router): any;
+    /** Register a route handler with proper middleware and argument injection */
+    __registerHandler(options: ExpressiveTeaHandlerOptions): ExpressMiddlewareHandler;
+});
+/**
+ * Routerize mixin - Adds Expressive Tea route capabilities to a controller class
+ *
+ * Transforms a regular class into an Expressive Tea route controller with:
+ * - Express router management
+ * - Route handler registration
+ * - Middleware support
+ * - Automatic argument injection from decorators
+ * - Annotation processing
+ *
+ * @template TBase - The base constructor type to extend
+ * @param {TBase} Route - The base controller class to extend
+ * @param {string} mountpoint - The path where this controller should be mounted
+ * @returns {RouterizedClass<TBase>} The enhanced class with route capabilities
+ *
+ * @example
+ * ```typescript
+ * @Route('/users')
+ * class UserController {
+ *   @Get('/')
+ *   getUsers() {
+ *     return ['user1', 'user2'];
+ *   }
+ * }
+ * ```
+ * @since 2.0.0
+ */
+export declare function Routerize<TBase extends Constructor>(Route: TBase, mountpoint: string): RouterizedClass<TBase>;

package/mixins/route.js

@@ -0,0 +1,96 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Routerize = Routerize;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const commons_1 = require("@expressive-tea/commons");
+const commons_2 = require("@expressive-tea/commons");
+const server_1 = require("../helpers/server");
+const inversify_1 = require("inversify");
+const DependencyInjection_1 = require("../services/DependencyInjection");
+/**
+ * Routerize mixin - Adds Expressive Tea route capabilities to a controller class
+ *
+ * Transforms a regular class into an Expressive Tea route controller with:
+ * - Express router management
+ * - Route handler registration
+ * - Middleware support
+ * - Automatic argument injection from decorators
+ * - Annotation processing
+ *
+ * @template TBase - The base constructor type to extend
+ * @param {TBase} Route - The base controller class to extend
+ * @param {string} mountpoint - The path where this controller should be mounted
+ * @returns {RouterizedClass<TBase>} The enhanced class with route capabilities
+ *
+ * @example
+ * ```typescript
+ * @Route('/users')
+ * class UserController {
+ *   @Get('/')
+ *   getUsers() {
+ *     return ['user1', 'user2'];
+ *   }
+ * }
+ * ```
+ * @since 2.0.0
+ */
+function Routerize(Route, mountpoint) {
+    let ExpressiveTeaRoute = class ExpressiveTeaRoute extends Route {
+        constructor(...args) {
+            var _a, _b;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            super(...args);
+            // Metadata is stored on the original class prototype by decorators
+            // Route is the base class, so Route.prototype is where metadata is stored
+            const handlers = (_a = commons_1.Metadata.get(commons_2.ROUTER_HANDLERS_KEY, Route.prototype)) !== null && _a !== void 0 ? _a : [];
+            this.router = (0, express_1.Router)();
+            this.mountpoint = mountpoint;
+            for (const handler of handlers) {
+                const middlewares = (_b = handler.handler.$middlewares) !== null && _b !== void 0 ? _b : [];
+                const verb = handler.verb;
+                const routeMethod = this.router[verb];
+                if (typeof routeMethod === 'function') {
+                    const allHandlers = [...middlewares, this.__registerHandler(handler)];
+                    routeMethod.apply(this.router, [handler.route, ...allHandlers]);
+                }
+            }
+        }
+        __mount(parent) {
+            // Metadata is stored on the original class prototype by decorators
+            const rootMiddlewares = commons_1.Metadata.get(commons_2.ROUTER_MIDDLEWARES_KEY, Route.prototype) || [];
+            parent.use(this.mountpoint, ...rootMiddlewares, this.router);
+            return this;
+        }
+        __registerHandler(options) {
+            const decoratedArguments = commons_1.Metadata.get(commons_2.ARGUMENTS_KEY, options.target, options.propertyKey);
+            const annotations = commons_1.Metadata.get(commons_2.ROUTER_ANNOTATIONS_KEY, options.target, options.propertyKey);
+            const optionsWithArgs = options;
+            return server_1.executeRequest.bind({
+                options: optionsWithArgs,
+                decoratedArguments,
+                annotations,
+                self: this
+            });
+        }
+    };
+    ExpressiveTeaRoute = tslib_1.__decorate([
+        (0, inversify_1.injectable)('Singleton'),
+        (0, inversify_1.injectFromBase)({ extendConstructorArguments: true }),
+        tslib_1.__metadata("design:paramtypes", [Object])
+    ], ExpressiveTeaRoute);
+    // Bind the original class to the wrapped class in the DI container
+    // This ensures that when modules request the original class via getInstanceOf(),
+    // they receive an instance of the wrapped ExpressiveTeaRoute class instead
+    try {
+        if (DependencyInjection_1.default.Container.isBound(Route)) {
+            DependencyInjection_1.default.Container.unbind(Route);
+        }
+        DependencyInjection_1.default.Container.bind(Route).to(ExpressiveTeaRoute);
+    }
+    catch (_a) {
+        // Binding may fail in some contexts, but that's okay - the class is still usable
+    }
+    return ExpressiveTeaRoute;
+}

package/package.json

@@ -0,0 +1,137 @@
+{
+  "name": "@expressive-tea/core",
+  "version": "2.0.0",
+  "description": "A modern TypeScript-first framework for building scalable Node.js applications with clean architecture, dependency injection, and decorator-driven development",
+  "main": "classes/Boot.js",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "test": "yarn linter && jest --maxWorkers=4 --coverage --detectOpenHandles --forceExit --silent",
+    "test:clear": "jest --clearCache",
+    "test:ci": "yarn linter:ci && yarn test:clear && jest --coverage  --ci --detectOpenHandles --forceExit --silent",
+    "test:dev": "yarn linter && yarn test:clear && jest --detectOpenHandles --forceExit",
+    "format": "prettier --ignore-path .gitignore --write \"**/*.+(js|ts|json)\"",
+    "linter": "eslint . --fix",
+    "linter:ci": "eslint .",
+    "build:dev": "tsc --project tsconfig.json --watch",
+    "build": "tsc --project tsconfig.json && resolve-tspaths --src . --out .",
+    "clean:build": "trash '**/*.js' '**/*.d.ts' '**/*.js.map' '**/*.d.ts.map' '!node_modules/**/*' '!docs/**/*' '!coverage/**/*' '!gulpfile.js' '!tasks/*.js' '!jest.config.js' '!tools/**/*'",
+    "publish:prepare": "npm run clean:build && npm run build",
+    "postpublish": "npm run clean:build",
+    "prepublishOnly": "npm test && npm run publish:prepare"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "contributors": [
+    "Diego Resendez <diego.resendez@zero-oneit.com>"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@eslint/eslintrc": "3.3.1",
+    "@eslint/js": "9.39.1",
+    "@expressive-tea/commons": "2026.1.1",
+    "@expressive-tea/plugin": "2026.1.1",
+    "@swc/core": "^1.15.11",
+    "@swc/jest": "^0.2.39",
+    "@types/express": "5.0.0",
+    "@types/express-http-proxy": "1.6.7",
+    "@types/express-serve-static-core": "4.19.7",
+    "@types/jest": "29.5.14",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "20.19.24",
+    "@types/supertest": "6.0.3",
+    "@types/ws": "8.18.1",
+    "@typescript-eslint/eslint-plugin": "8.46.4",
+    "@typescript-eslint/parser": "8.46.4",
+    "eslint": "9.39.1",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-jsdoc": "61.1.12",
+    "eslint-plugin-n": "17.23.1",
+    "eslint-plugin-prefer-arrow": "1.2.3",
+    "eslint-plugin-promise": "7.2.1",
+    "globals": "16.5.0",
+    "http-terminator": "3.2.0",
+    "jest": "30.2.0",
+    "jest-express": "1.12.0",
+    "jest-junit": "16.0.0",
+    "prettier": "^3.8.1",
+    "reflect-metadata": "0.2.2",
+    "resolve-tspaths": "0.8.23",
+    "rimraf": "6.1.0",
+    "supertest": "7.1.4",
+    "toast-jsdoc": "1.0.2",
+    "trash-cli": "7.0.0",
+    "ts-jest": "29.4.5",
+    "ts-jest-resolver": "2.0.1",
+    "ts-node": "10.9.2",
+    "tsconfig-paths": "4.2.0",
+    "tslib": "2.8.1",
+    "typescript": "5.9.3"
+  },
+  "dependencies": {
+    "chalk": "4.1.2",
+    "dotenv": "^16.4.5",
+    "express": "5.2.1",
+    "express-http-proxy": "2.1.2",
+    "inversify": "7.11.0",
+    "inversify-inject-decorators": "3.1.0",
+    "js-yaml": "^4.1.0",
+    "lodash": "4.17.23",
+    "socket.io": "4.8.1",
+    "socket.io-client": "4.8.1",
+    "url-scheme": "1.0.5",
+    "ws": "8.18.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Expressive-Tea/expresive-tea.git"
+  },
+  "keywords": [
+    "typescript",
+    "typescript-framework",
+    "express",
+    "express-typescript",
+    "decorators",
+    "dependency-injection",
+    "inversify",
+    "rest-api",
+    "api-framework",
+    "backend-framework",
+    "nodejs-framework",
+    "mvc-framework",
+    "clean-architecture",
+    "type-safe",
+    "server-framework",
+    "microservices",
+    "websocket",
+    "socket.io",
+    "health-checks",
+    "middleware",
+    "controllers",
+    "routing",
+    "ioc-container",
+    "modern-backend"
+  ],
+  "bugs": {
+    "url": "https://github.com/Expressive-Tea/expresive-tea/issues"
+  },
+  "homepage": "https://github.com/Expressive-Tea/expresive-tea#readme",
+  "optionalDependencies": {
+    "bufferutil": "4.0.9",
+    "utf-8-validate": "6.0.5"
+  },
+  "resolutions": {
+    "set-value": "4.1.0",
+    "glob-parent": "6.0.2",
+    "engine.io": "6.4.2",
+    "@typescript-eslint/eslint-plugin": "8.46.4",
+    "@typescript-eslint/parser": "8.46.4",
+    "eslint": "9.39.1",
+    "eslint-plugin-n": "17.23.1",
+    "eslint-plugin-promise": "7.2.1"
+  },
+  "packageManager": "yarn@4.11.0"
+}

package/services/DependencyInjection.d.ts

@@ -0,0 +1,159 @@
+import { Container, Newable, ServiceIdentifier } from 'inversify';
+import { LazyInversifyDecorator, LazyInversifyNamedDecorator, LazyInversifyTaggedDecorator } from '../types/inversify';
+/**
+ * @module Services
+ */
+/**
+ * This Class contain the helpers to add on the dynamically Dependency Injection Providers which will be used globally
+ * by all the components.
+ * @class DependencyInjection
+ * @summary Define a Dependency Injection Provider
+ */
+declare class DependencyInjection {
+    /**
+     * This is the implementation of a global inversify container that helps to contains every Dependency Injection.
+     * @type {InversifyContainers}
+     * @static
+     * @readonly
+     * @summary Inversify Container
+     */
+    static readonly Container: Container;
+    /**
+     * Map of scoped containers for module-level isolation.
+     * @type {Map<string, Container>}
+     * @private
+     * @static
+     * @since 2.0.0
+     */
+    private static scopedContainers;
+    /**
+     * This assign to the global inversify container Express Tea can set provider as user required to the global container
+     * and shareable to all registered modules. This method is used if required to assign a provider depending on params
+     * or data flow.
+     *
+     * @param {Class} ProviderFactory - Assign the Class to serve as factory.
+     * @param {string | symbol} [providerName="ClassName"] - Provide the provider identification.
+     * @summary Add Provider to Dependency Injection Providers
+     */
+    static setProvider(ProviderFactory: Newable<any>, providerName?: ServiceIdentifier<string | symbol>): void;
+    /**
+     * Create a new scoped container for module-level dependency isolation.
+     * The scoped container inherits from the root container but maintains its own bindings.
+     *
+     * @param {string} scopeName - Unique identifier for the scope
+     * @returns {Container} The newly created scoped container
+     * @throws {Error} If a scope with the same name already exists
+     * @static
+     * @since 2.0.0
+     * @summary Create a scoped DI container
+     *
+     * @example
+     * const moduleScope = DependencyInjection.createScope('user-module');
+     * moduleScope.bind(UserService).toSelf();
+     */
+    static createScope(scopeName: string): Container;
+    /**
+     * Retrieve an existing scoped container by name.
+     *
+     * @param {string} scopeName - Unique identifier for the scope
+     * @returns {Container | undefined} The scoped container, or undefined if not found
+     * @static
+     * @since 2.0.0
+     * @summary Get a scoped DI container
+     *
+     * @example
+     * const moduleScope = DependencyInjection.getScope('user-module');
+     * if (moduleScope) {
+     *   const service = moduleScope.get(UserService);
+     * }
+     */
+    static getScope(scopeName: string): Container | undefined;
+    /**
+     * Destroy a scoped container and remove it from the registry.
+     * This unbinds all services within the scope and cleans up resources.
+     *
+     * @param {string} scopeName - Unique identifier for the scope
+     * @returns {boolean} True if the scope was found and destroyed, false otherwise
+     * @static
+     * @since 2.0.0
+     * @summary Destroy a scoped DI container
+     *
+     * @example
+     * const destroyed = DependencyInjection.destroyScope('user-module');
+     * if (destroyed) {
+     *   console.log('Scope destroyed successfully');
+     * }
+     */
+    static destroyScope(scopeName: string): boolean;
+    /**
+     * Get all registered scope names.
+     *
+     * @returns {string[]} Array of scope names
+     * @static
+     * @since 2.0.0
+     * @summary Get all scope names
+     *
+     * @example
+     * const scopes = DependencyInjection.getAllScopeNames();
+     * console.log('Active scopes:', scopes);
+     */
+    static getAllScopeNames(): string[];
+    /**
+     * Check if a scope exists.
+     *
+     * @param {string} scopeName - Unique identifier for the scope
+     * @returns {boolean} True if the scope exists, false otherwise
+     * @static
+     * @since 2.0.0
+     * @summary Check if scope exists
+     *
+     * @example
+     * if (DependencyInjection.hasScope('user-module')) {
+     *   console.log('Scope exists');
+     * }
+     */
+    static hasScope(scopeName: string): boolean;
+}
+/**
+ * @module Decorators/DependencyInjection
+ */
+/**
+ * This annotation allow inject directly into a class property an instance of the provider as is passed on the
+ * provider declaration, checkout
+ * {@link https://github.com/inversify/InversifyJS/blob/master/wiki/classes_as_id.md Classes as ID}
+ * from Inversify Project.
+ * @decorator {PropertyDecorator} Inject - Inject a dependency constructor defined as provider.
+ * @summary Inject a instance of provider defined as Dependency Injection.
+ * @function
+ */
+export declare const Inject: LazyInversifyDecorator;
+/**
+ * This implement the Tagged Bindings from Inversify to used on the contructors arguments of the injectable classes and
+ * allow not create ambiguous match as named annotation, also check out
+ * {@link https://github.com/inversify/InversifyJS/blob/master/wiki/named_bindings.md Named Bindings}
+ * from Inversify Project.
+ * @decorator {ConstructorParameter} InjectNamed - Inject a provider instance on costructor arguments.
+ * @summary Bind provider as named annotation.
+ * @function
+ */
+export declare const InjectNamed: LazyInversifyNamedDecorator;
+/**
+ * This implement the Named Bindings from Inversify to used on the contructors arguments of the injectable classes and
+ * allow not create ambiguous match as tagged annotation.
+ * {@link https://github.com/inversify/InversifyJS/blob/master/wiki/tagged_bindings.md Tagged Bindings}
+ * @decorator {ConstructorParameter} InjectTagged - Inject a provider instance on costructor arguments.
+ * @summary Bind provider as tagged annotation.
+ * @function
+ */
+export declare const InjectTagged: LazyInversifyTaggedDecorator;
+/**
+ * Bind an array of bind providers  with the same name over the constructor parameter.
+ * {@link https://github.com/inversify/InversifyJS/blob/master/wiki/multi_injection.md Multiple Injection}
+ * @decorator {ConstructorParameter} MultiInject - Inject an array of providers under same name.
+ * @summary Define multiple concretions for defined inject.
+ * @function
+ */
+export declare const MultiInject: LazyInversifyDecorator;
+export declare function defineConstant<T>(name: string | symbol, value: T): void;
+export declare function getInstanceOf<T>(Target: Newable<T>): T;
+export default DependencyInjection;

package/services/DependencyInjection.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiInject = exports.InjectTagged = exports.InjectNamed = exports.Inject = void 0;
+exports.defineConstant = defineConstant;
+exports.getInstanceOf = getInstanceOf;
+const inversify_1 = require("inversify");
+const inversify_config_1 = require("../inversify.config");
+const inversify_inject_decorators_1 = require("inversify-inject-decorators");
+const rootContainer = new inversify_1.Container({
+    autobind: true,
+    parent: inversify_config_1.default,
+});
+const lazyDecorators = (0, inversify_inject_decorators_1.default)(rootContainer);
+/**
+ * @module Services
+ */
+/**
+ * This Class contain the helpers to add on the dynamically Dependency Injection Providers which will be used globally
+ * by all the components.
+ * @class DependencyInjection
+ * @summary Define a Dependency Injection Provider
+ */
+class DependencyInjection {
+    /**
+     * This assign to the global inversify container Express Tea can set provider as user required to the global container
+     * and shareable to all registered modules. This method is used if required to assign a provider depending on params
+     * or data flow.
+     *
+     * @param {Class} ProviderFactory - Assign the Class to serve as factory.
+     * @param {string | symbol} [providerName="ClassName"] - Provide the provider identification.
+     * @summary Add Provider to Dependency Injection Providers
+     */
+    static setProvider(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ProviderFactory, providerName) {
+        if (!rootContainer.isBound(providerName !== null && providerName !== void 0 ? providerName : ProviderFactory.name)) {
+            rootContainer.bind(providerName !== null && providerName !== void 0 ? providerName : ProviderFactory.name).to(ProviderFactory);
+        }
+    }
+    /**
+     * Create a new scoped container for module-level dependency isolation.
+     * The scoped container inherits from the root container but maintains its own bindings.
+     *
+     * @param {string} scopeName - Unique identifier for the scope
+     * @returns {Container} The newly created scoped container
+     * @throws {Error} If a scope with the same name already exists
+     * @static
+     * @since 2.0.0
+     * @summary Create a scoped DI container
+     *
+     * @example
+     * const moduleScope = DependencyInjection.createScope('user-module');
+     * moduleScope.bind(UserService).toSelf();
+     */
+    static createScope(scopeName) {
+        if (DependencyInjection.scopedContainers.has(scopeName)) {
+            throw new Error(`Scope "${scopeName}" already exists`);
+        }
+        const scopedContainer = new inversify_1.Container({ parent: rootContainer });
+        DependencyInjection.scopedContainers.set(scopeName, scopedContainer);
+        return scopedContainer;
+    }
+    /**
+     * Retrieve an existing scoped container by name.
+     *
+     * @param {string} scopeName - Unique identifier for the scope
+     * @returns {Container | undefined} The scoped container, or undefined if not found
+     * @static
+     * @since 2.0.0
+     * @summary Get a scoped DI container
+     *
+     * @example
+     * const moduleScope = DependencyInjection.getScope('user-module');
+     * if (moduleScope) {
+     *   const service = moduleScope.get(UserService);
+     * }
+     */
+    static getScope(scopeName) {
+        return DependencyInjection.scopedContainers.get(scopeName);
+    }
+    /**
+     * Destroy a scoped container and remove it from the registry.
+     * This unbinds all services within the scope and cleans up resources.
+     *
+     * @param {string} scopeName - Unique identifier for the scope
+     * @returns {boolean} True if the scope was found and destroyed, false otherwise
+     * @static
+     * @since 2.0.0
+     * @summary Destroy a scoped DI container
+     *
+     * @example
+     * const destroyed = DependencyInjection.destroyScope('user-module');
+     * if (destroyed) {
+     *   console.log('Scope destroyed successfully');
+     * }
+     */
+    static destroyScope(scopeName) {
+        const scopedContainer = DependencyInjection.scopedContainers.get(scopeName);
+        if (scopedContainer) {
+            scopedContainer.unbindAll();
+            DependencyInjection.scopedContainers.delete(scopeName);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get all registered scope names.
+     *
+     * @returns {string[]} Array of scope names
+     * @static
+     * @since 2.0.0
+     * @summary Get all scope names
+     *
+     * @example
+     * const scopes = DependencyInjection.getAllScopeNames();
+     * console.log('Active scopes:', scopes);
+     */
+    static getAllScopeNames() {
+        return Array.from(DependencyInjection.scopedContainers.keys());
+    }
+    /**
+     * Check if a scope exists.
+     *
+     * @param {string} scopeName - Unique identifier for the scope
+     * @returns {boolean} True if the scope exists, false otherwise
+     * @static
+     * @since 2.0.0
+     * @summary Check if scope exists
+     *
+     * @example
+     * if (DependencyInjection.hasScope('user-module')) {
+     *   console.log('Scope exists');
+     * }
+     */
+    static hasScope(scopeName) {
+        return DependencyInjection.scopedContainers.has(scopeName);
+    }
+}
+/**
+ * This is the implementation of a global inversify container that helps to contains every Dependency Injection.
+ * @type {InversifyContainers}
+ * @static
+ * @readonly
+ * @summary Inversify Container
+ */
+DependencyInjection.Container = rootContainer;
+/**
+ * Map of scoped containers for module-level isolation.
+ * @type {Map<string, Container>}
+ * @private
+ * @static
+ * @since 2.0.0
+ */
+DependencyInjection.scopedContainers = new Map();
+/**
+ * @module Decorators/DependencyInjection
+ */
+/**
+ * This annotation allow inject directly into a class property an instance of the provider as is passed on the
+ * provider declaration, checkout
+ * {@link https://github.com/inversify/InversifyJS/blob/master/wiki/classes_as_id.md Classes as ID}
+ * from Inversify Project.
+ * @decorator {PropertyDecorator} Inject - Inject a dependency constructor defined as provider.
+ * @summary Inject a instance of provider defined as Dependency Injection.
+ * @function
+ */
+exports.Inject = lazyDecorators.lazyInject;
+/**
+ * This implement the Tagged Bindings from Inversify to used on the contructors arguments of the injectable classes and
+ * allow not create ambiguous match as named annotation, also check out
+ * {@link https://github.com/inversify/InversifyJS/blob/master/wiki/named_bindings.md Named Bindings}
+ * from Inversify Project.
+ * @decorator {ConstructorParameter} InjectNamed - Inject a provider instance on costructor arguments.
+ * @summary Bind provider as named annotation.
+ * @function
+ */
+exports.InjectNamed = lazyDecorators.lazyInjectNamed;
+/**
+ * This implement the Named Bindings from Inversify to used on the contructors arguments of the injectable classes and
+ * allow not create ambiguous match as tagged annotation.
+ * {@link https://github.com/inversify/InversifyJS/blob/master/wiki/tagged_bindings.md Tagged Bindings}
+ * @decorator {ConstructorParameter} InjectTagged - Inject a provider instance on costructor arguments.
+ * @summary Bind provider as tagged annotation.
+ * @function
+ */
+exports.InjectTagged = lazyDecorators.lazyInjectTagged;
+/**
+ * Bind an array of bind providers  with the same name over the constructor parameter.
+ * {@link https://github.com/inversify/InversifyJS/blob/master/wiki/multi_injection.md Multiple Injection}
+ * @decorator {ConstructorParameter} MultiInject - Inject an array of providers under same name.
+ * @summary Define multiple concretions for defined inject.
+ * @function
+ */
+exports.MultiInject = lazyDecorators.lazyMultiInject;
+function defineConstant(name, value) {
+    DependencyInjection.Container.bind(name).toConstantValue(value);
+}
+function getInstanceOf(Target) {
+    return DependencyInjection.Container.get(Target);
+}
+exports.default = DependencyInjection;

package/services/WebsocketService.d.ts

@@ -0,0 +1,18 @@
+import type WebSocket from 'ws';
+import type * as http from 'http';
+import * as https from 'https';
+export default class WebsocketService {
+    static instance: WebsocketService | undefined;
+    private ws;
+    private wss;
+    httpServer: http.Server;
+    httpsServer: https.Server;
+    constructor(ws?: WebSocket.Server, wss?: WebSocket.Server);
+    getWebsocket(httpServer: http.Server | https.Server): WebSocket.Server;
+    setHttpServer(httpServer: http.Server | https.Server): void;
+    setWebSocket(ws: WebSocket.Server): void;
+    setSecureWebsocket(wss: WebSocket.Server): void;
+    static getInstance(ws?: WebSocket.Server, wss?: WebSocket.Server): WebsocketService;
+    static init(ws?: WebSocket.Server, wss?: WebSocket.Server): void;
+    static clear(): void;
+}