@zerooneit/expressive-tea 1.3.0-beta.5 → 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

@@ -1,21 +1,25 @@
 {
   "name": "@zerooneit/expressive-tea",
-  "version": "1.3.0-beta.5",
-  "description": "A REST API  over Express and Typescript",
+  "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": ">=16.0.0"
+    "node": ">=20.0.0"
   },
   "scripts": {
-    "test": "yarn run linter && jest --clearCache && jest --coverage  --ci --detectOpenHandles --forceExit --silent",
-    "test:dev": "yarn run linter && jest --clearCache && jest --detectOpenHandles --forceExit",
-    "linter": "tslint -c tslint.json -p tsconfig.json",
+    "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",
+    "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": "yarn run clean:build && yarn run build",
-    "postpublish": "yarn run clean:build",
-    "prepublishOnly": "yarn test && yarn run publish:prepare"
+    "publish:prepare": "npm run clean:build && npm run build",
+    "postpublish": "npm run clean:build",
+    "prepublishOnly": "npm run publish:prepare"
   },
   "publishConfig": {
     "access": "public"
@@ -25,91 +29,109 @@
   ],
   "license": "Apache-2.0",
   "devDependencies": {
-    "@expressive-tea/commons": "^1.0.1",
-    "@expressive-tea/plugin": "1.0.3",
-    "@types/express": "4.17.17",
-    "@types/express-http-proxy": "1.6.3",
-    "@types/express-serve-static-core": "4.17.34",
-    "@types/jest": "29.5.1",
-    "@types/lodash": "4.14.194",
-    "@types/node": "20.1.0",
-    "@types/reflect-metadata": "0.1.0",
-    "@types/socket.io": "3.0.2",
-    "@types/socket.io-client": "3.0.0",
-    "@types/ws": "8.5.4",
+    "@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": "29.5.0",
+    "jest": "30.2.0",
     "jest-express": "1.12.0",
     "jest-junit": "16.0.0",
-    "reflect-metadata": "0.1.13",
-    "rimraf": "5.0.0",
-    "supertest": "6.3.3",
+    "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": "5.0.0",
-    "ts-jest": "29.1.0",
-    "ts-node": "10.9.1",
-    "tslint": "6.1.3",
-    "typescript": "5.0.4"
+    "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": {
-    "express": "4.18.2",
-    "express-http-proxy": "1.6.3",
-    "inversify": "6.0.1",
+    "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",
-    "lodash": "4.17.21",
-    "socket.io": "4.6.1",
-    "socket.io-client": "4.6.1",
+    "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.13.0"
+    "ws": "8.18.3"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Zero-OneiT/expresive-tea.git"
+    "url": "git+https://github.com/Expressive-Tea/expresive-tea.git"
   },
   "keywords": [
-    "Typescript",
     "typescript",
-    "Express",
-    "Decorators",
-    "decorators",
-    "decorator",
-    "controller",
-    "inject",
-    "ioc",
-    "di",
-    "mvc",
-    "es6",
-    "es2015",
-    "REST",
-    "API",
+    "typescript-framework",
     "express",
-    "webserver",
-    "route",
-    "router",
-    "express-ts",
-    "restful",
-    "server",
+    "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",
-    "web",
-    "service",
-    "backend",
-    "services",
-    "node",
-    "nodejs"
+    "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.7",
-    "utf-8-validate": "^6.0.0"
+    "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"
+    "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@3.5.1"
+  "packageManager": "yarn@4.11.0"
 }

package/services/DependencyInjection.d.ts

@@ -1,4 +1,5 @@
-import { Container } from 'inversify';
+import { Container, Newable, ServiceIdentifier } from 'inversify';
+import { LazyInversifyDecorator, LazyInversifyNamedDecorator, LazyInversifyTaggedDecorator } from '../types/inversify';
 /**
  * @module Services
  */
@@ -17,16 +18,101 @@ declare class DependencyInjection {
      * @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 |never } [providerName="ClassName"] - Provide the provider identification.
+     * @param {string | symbol} [providerName="ClassName"] - Provide the provider identification.
      * @summary Add Provider to Dependency Injection Providers
      */
-    static setProvider(ProviderFactory: any, providerName?: string | symbol): void;
+    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
@@ -40,7 +126,7 @@ declare class DependencyInjection {
  * @summary Inject a instance of provider defined as Dependency Injection.
  * @function
  */
-export declare const Inject: (...args: any[]) => any;
+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
@@ -50,7 +136,7 @@ export declare const Inject: (...args: any[]) => any;
  * @summary Bind provider as named annotation.
  * @function
  */
-export declare const InjectNamed: (...args: any[]) => any;
+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.
@@ -59,7 +145,7 @@ export declare const InjectNamed: (...args: any[]) => any;
  * @summary Bind provider as tagged annotation.
  * @function
  */
-export declare const InjectTagged: (...args: any[]) => any;
+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}
@@ -67,5 +153,7 @@ export declare const InjectTagged: (...args: any[]) => any;
  * @summary Define multiple concretions for defined inject.
  * @function
  */
-export declare const MultiInject: (...args: any[]) => any;
+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

@@ -1,10 +1,14 @@
 "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({
-    autoBindInjectable: true
+    autobind: true,
+    parent: inversify_config_1.default,
 });
 const lazyDecorators = (0, inversify_inject_decorators_1.default)(rootContainer);
 /**
@@ -23,14 +27,114 @@ class DependencyInjection {
      * or data flow.
      *
      * @param {Class} ProviderFactory - Assign the Class to serve as factory.
-     * @param {string | symbol |never } [providerName="ClassName"] - Provide the provider identification.
+     * @param {string | symbol} [providerName="ClassName"] - Provide the provider identification.
      * @summary Add Provider to Dependency Injection Providers
      */
-    static setProvider(ProviderFactory, providerName) {
-        if (!rootContainer.isBound(providerName || ProviderFactory.name)) {
-            rootContainer.bind(providerName || ProviderFactory.name).to(ProviderFactory);
+    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.
@@ -40,6 +144,14 @@ class DependencyInjection {
  * @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
  */
@@ -80,4 +192,10 @@ exports.InjectTagged = lazyDecorators.lazyInjectTagged;
  * @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;