@expressots/core 3.0.0-beta.4 → 4.0.0-preview.1

package/lib/cjs/di/planning/planner.js

@@ -26,18 +26,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.plan = plan;
 exports.createMockRequest = createMockRequest;
 exports.getBindingDictionary = getBindingDictionary;
-const binding_count_1 = require("../bindings/binding_count");
-const ERROR_MSGS = __importStar(require("../constants/error_msgs"));
-const literal_types_1 = require("../constants/literal_types");
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const exceptions_1 = require("../utils/exceptions");
-const serialization_1 = require("../utils/serialization");
-const context_1 = require("./context");
-const metadata_1 = require("./metadata");
-const plan_1 = require("./plan");
-const reflection_utils_1 = require("./reflection_utils");
-const request_1 = require("./request");
-const target_1 = require("./target");
+const binding_count_js_1 = require("../bindings/binding_count.js");
+const ERROR_MSGS = __importStar(require("../constants/error_msgs.js"));
+const literal_types_js_1 = require("../constants/literal_types.js");
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const exceptions_js_1 = require("../utils/exceptions.js");
+const serialization_js_1 = require("../utils/serialization.js");
+const context_js_1 = require("./context.js");
+const metadata_js_1 = require("./metadata.js");
+const plan_js_1 = require("./plan.js");
+const reflection_utils_js_1 = require("./reflection_utils.js");
+const request_js_1 = require("./request.js");
+const target_js_1 = require("./target.js");
 function getBindingDictionary(cntnr) {
     return cntnr._bindingDictionary;
 }
@@ -45,10 +45,10 @@ function _createTarget(isMultiInject, targetType, serviceIdentifier, name, key,
     const metadataKey = isMultiInject
         ? METADATA_KEY.MULTI_INJECT_TAG
         : METADATA_KEY.INJECT_TAG;
-    const injectMetadata = new metadata_1.Metadata(metadataKey, serviceIdentifier);
-    const target = new target_1.Target(targetType, name, serviceIdentifier, injectMetadata);
+    const injectMetadata = new metadata_js_1.Metadata(metadataKey, serviceIdentifier);
+    const target = new target_js_1.Target(targetType, name, serviceIdentifier, injectMetadata);
     if (key !== undefined) {
-        const tagMetadata = new metadata_1.Metadata(key, value);
+        const tagMetadata = new metadata_js_1.Metadata(key, value);
         target.metadata.push(tagMetadata);
     }
     return target;
@@ -57,7 +57,7 @@ function _getActiveBindings(metadataReader, avoidConstraints, context, parentReq
     let bindings = getBindings(context.container, target.serviceIdentifier);
     let activeBindings = [];
     // automatic binding
-    if (bindings.length === binding_count_1.BindingCount.NoBindingsAvailable &&
+    if (bindings.length === binding_count_js_1.BindingCount.NoBindingsAvailable &&
         context.container.options.autoBindInjectable &&
         typeof target.serviceIdentifier === "function" &&
         metadataReader.getConstructorMetadata(target.serviceIdentifier)
@@ -69,7 +69,7 @@ function _getActiveBindings(metadataReader, avoidConstraints, context, parentReq
     if (!avoidConstraints) {
         // apply constraints if available to reduce the number of active bindings
         activeBindings = bindings.filter((binding) => {
-            const request = new request_1.Request(binding.serviceIdentifier, context, parentRequest, binding, target);
+            const request = new request_js_1.Request(binding.serviceIdentifier, context, parentRequest, binding, target);
             return binding.constraint(request);
         });
     }
@@ -83,25 +83,25 @@ function _getActiveBindings(metadataReader, avoidConstraints, context, parentReq
 }
 function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
     switch (bindings.length) {
-        case binding_count_1.BindingCount.NoBindingsAvailable:
+        case binding_count_js_1.BindingCount.NoBindingsAvailable:
             if (target.isOptional()) {
                 return bindings;
             }
             else {
-                const serviceIdentifierString = (0, serialization_1.getServiceIdentifierAsString)(serviceIdentifier);
+                const serviceIdentifierString = (0, serialization_js_1.getServiceIdentifierAsString)(serviceIdentifier);
                 let msg = ERROR_MSGS.NOT_REGISTERED;
-                msg += (0, serialization_1.listMetadataForTarget)(serviceIdentifierString, target);
-                msg += (0, serialization_1.listRegisteredBindingsForServiceIdentifier)(container, serviceIdentifierString, getBindings);
+                msg += (0, serialization_js_1.listMetadataForTarget)(serviceIdentifierString, target);
+                msg += (0, serialization_js_1.listRegisteredBindingsForServiceIdentifier)(container, serviceIdentifierString, getBindings);
                 throw new Error(msg);
             }
-        case binding_count_1.BindingCount.OnlyOneBindingAvailable:
+        case binding_count_js_1.BindingCount.OnlyOneBindingAvailable:
             return bindings;
-        case binding_count_1.BindingCount.MultipleBindingsAvailable:
+        case binding_count_js_1.BindingCount.MultipleBindingsAvailable:
         default:
             if (!target.isArray()) {
-                const serviceIdentifierString = (0, serialization_1.getServiceIdentifierAsString)(serviceIdentifier);
+                const serviceIdentifierString = (0, serialization_js_1.getServiceIdentifierAsString)(serviceIdentifier);
                 let msg = `${ERROR_MSGS.AMBIGUOUS_MATCH} ${serviceIdentifierString}`;
-                msg += (0, serialization_1.listRegisteredBindingsForServiceIdentifier)(container, serviceIdentifierString, getBindings);
+                msg += (0, serialization_js_1.listRegisteredBindingsForServiceIdentifier)(container, serviceIdentifierString, getBindings);
                 throw new Error(msg);
             }
             else {
@@ -114,8 +114,8 @@ function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier,
     let childRequest;
     if (parentRequest === null) {
         activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, null, target);
-        childRequest = new request_1.Request(serviceIdentifier, context, null, activeBindings, target);
-        const thePlan = new plan_1.Plan(context, childRequest);
+        childRequest = new request_js_1.Request(serviceIdentifier, context, null, activeBindings, target);
+        const thePlan = new plan_js_1.Plan(context, childRequest);
         context.addPlan(thePlan);
     }
     else {
@@ -133,16 +133,16 @@ function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier,
             }
             subChildRequest = childRequest;
         }
-        if (binding.type === literal_types_1.BindingTypeEnum.Instance &&
+        if (binding.type === literal_types_js_1.BindingTypeEnum.Instance &&
             binding.implementationType !== null) {
-            const dependencies = (0, reflection_utils_1.getDependencies)(metadataReader, binding.implementationType);
+            const dependencies = (0, reflection_utils_js_1.getDependencies)(metadataReader, binding.implementationType);
             if (!context.container.options.skipBaseClassChecks) {
                 // Throw if a derived class does not implement its constructor explicitly
                 // We do this to prevent errors when a base class (parent) has dependencies
                 // and one of the derived classes (children) has no dependencies
-                const baseClassDependencyCount = (0, reflection_utils_1.getBaseClassDependencyCount)(metadataReader, binding.implementationType);
+                const baseClassDependencyCount = (0, reflection_utils_js_1.getBaseClassDependencyCount)(metadataReader, binding.implementationType);
                 if (dependencies.length < baseClassDependencyCount) {
-                    const error = ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH((0, reflection_utils_1.getFunctionName)(binding.implementationType));
+                    const error = ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH((0, reflection_utils_js_1.getFunctionName)(binding.implementationType));
                     throw new Error(error);
                 }
             }
@@ -165,22 +165,22 @@ function getBindings(container, serviceIdentifier) {
     return bindings;
 }
 function plan(metadataReader, container, isMultiInject, targetType, serviceIdentifier, key, value, avoidConstraints = false) {
-    const context = new context_1.Context(container);
+    const context = new context_js_1.Context(container);
     const target = _createTarget(isMultiInject, targetType, serviceIdentifier, "", key, value);
     try {
         _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, null, target);
         return context;
     }
     catch (error) {
-        if ((0, exceptions_1.isStackOverflowExeption)(error)) {
-            (0, serialization_1.circularDependencyToException)(context.plan.rootRequest);
+        if ((0, exceptions_js_1.isStackOverflowExeption)(error)) {
+            (0, serialization_js_1.circularDependencyToException)(context.plan.rootRequest);
         }
         throw error;
     }
 }
 function createMockRequest(container, serviceIdentifier, key, value) {
-    const target = new target_1.Target(literal_types_1.TargetTypeEnum.Variable, "", serviceIdentifier, new metadata_1.Metadata(key, value));
-    const context = new context_1.Context(container);
-    const request = new request_1.Request(serviceIdentifier, context, null, [], target);
+    const target = new target_js_1.Target(literal_types_js_1.TargetTypeEnum.Variable, "", serviceIdentifier, new metadata_js_1.Metadata(key, value));
+    const context = new context_js_1.Context(container);
+    const request = new request_js_1.Request(serviceIdentifier, context, null, [], target);
     return request;
 }

package/lib/cjs/di/planning/reflection_utils.js

@@ -26,15 +26,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFunctionName = void 0;
 exports.getDependencies = getDependencies;
 exports.getBaseClassDependencyCount = getBaseClassDependencyCount;
-const lazy_service_identifier_1 = require("../annotation/lazy_service_identifier");
-const ERROR_MSGS = __importStar(require("../constants/error_msgs"));
-const literal_types_1 = require("../constants/literal_types");
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const serialization_1 = require("../utils/serialization");
-Object.defineProperty(exports, "getFunctionName", { enumerable: true, get: function () { return serialization_1.getFunctionName; } });
-const target_1 = require("./target");
+const lazy_service_identifier_js_1 = require("../annotation/lazy_service_identifier.js");
+const ERROR_MSGS = __importStar(require("../constants/error_msgs.js"));
+const literal_types_js_1 = require("../constants/literal_types.js");
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const serialization_js_1 = require("../utils/serialization.js");
+Object.defineProperty(exports, "getFunctionName", { enumerable: true, get: function () { return serialization_js_1.getFunctionName; } });
+const target_js_1 = require("./target.js");
 function getDependencies(metadataReader, func) {
-    const constructorName = (0, serialization_1.getFunctionName)(func);
+    const constructorName = (0, serialization_js_1.getFunctionName)(func);
     return getTargets(metadataReader, constructorName, func, false);
 }
 function getTargets(metadataReader, constructorName, func, isBaseClass) {
@@ -72,7 +72,7 @@ function getConstructorArgsAsTarget(index, isBaseClass, constructorName, service
     const injectIdentifier = metadata.inject || metadata.multiInject;
     serviceIdentifier = (injectIdentifier ? injectIdentifier : serviceIdentifier);
     // we unwrap LazyServiceIdentifier wrappers to allow circular dependencies on symbols
-    if (serviceIdentifier instanceof lazy_service_identifier_1.LazyServiceIdentifier) {
+    if (serviceIdentifier instanceof lazy_service_identifier_js_1.LazyServiceIdentifier) {
         serviceIdentifier = serviceIdentifier.unwrap();
     }
     // Types Object and Function are too ambiguous to be resolved
@@ -86,7 +86,7 @@ function getConstructorArgsAsTarget(index, isBaseClass, constructorName, service
             const msg = `${ERROR_MSGS.MISSING_INJECT_ANNOTATION} argument ${index} in class ${constructorName}.`;
             throw new Error(msg);
         }
-        const target = new target_1.Target(literal_types_1.TargetTypeEnum.ConstructorArgument, metadata.targetName, serviceIdentifier);
+        const target = new target_js_1.Target(literal_types_js_1.TargetTypeEnum.ConstructorArgument, metadata.targetName, serviceIdentifier);
         target.metadata = targetMetadata;
         return target;
     }
@@ -126,7 +126,7 @@ function getClassPropsAsTargets(metadataReader, constructorFunc, constructorName
         // Take types to be injected from user-generated metadata
         const serviceIdentifier = _getServiceIdentifierForProperty(metadata.inject, metadata.multiInject, key, constructorName);
         // The property target
-        const target = new target_1.Target(literal_types_1.TargetTypeEnum.ClassProperty, identifier, serviceIdentifier);
+        const target = new target_js_1.Target(literal_types_js_1.TargetTypeEnum.ClassProperty, identifier, serviceIdentifier);
         target.metadata = targetMetadata;
         targets.push(target);
     }
@@ -142,7 +142,7 @@ function getBaseClassDependencyCount(metadataReader, func) {
     const baseConstructor = Object.getPrototypeOf(func.prototype).constructor;
     if (baseConstructor !== Object) {
         // get targets for base class
-        const baseConstructorName = (0, serialization_1.getFunctionName)(baseConstructor);
+        const baseConstructorName = (0, serialization_js_1.getFunctionName)(baseConstructor);
         const targets = getTargets(metadataReader, baseConstructorName, baseConstructor, true);
         // get unmanaged metadata
         const metadata = targets.map((t) => t.metadata.filter((m) => m.key === METADATA_KEY.UNMANAGED_TAG));

package/lib/cjs/di/planning/request.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Request = void 0;
-const id_1 = require("../utils/id");
+const id_js_1 = require("../utils/id.js");
 class Request {
     constructor(serviceIdentifier, parentContext, parentRequest, bindings, target) {
-        this.id = (0, id_1.id)();
+        this.id = (0, id_js_1.id)();
         this.serviceIdentifier = serviceIdentifier;
         this.parentContext = parentContext;
         this.parentRequest = parentRequest;

package/lib/cjs/di/planning/target.js

@@ -24,28 +24,28 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Target = void 0;
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const id_1 = require("../utils/id");
-const serialization_1 = require("../utils/serialization");
-const metadata_1 = require("./metadata");
-const queryable_string_1 = require("./queryable_string");
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const id_js_1 = require("../utils/id.js");
+const serialization_js_1 = require("../utils/serialization.js");
+const metadata_js_1 = require("./metadata.js");
+const queryable_string_js_1 = require("./queryable_string.js");
 class Target {
     constructor(type, identifier, serviceIdentifier, namedOrTagged) {
-        this.id = (0, id_1.id)();
+        this.id = (0, id_js_1.id)();
         this.type = type;
         this.serviceIdentifier = serviceIdentifier;
         const queryableName = typeof identifier === "symbol"
-            ? (0, serialization_1.getSymbolDescription)(identifier)
+            ? (0, serialization_js_1.getSymbolDescription)(identifier)
             : identifier;
-        this.name = new queryable_string_1.QueryableString(queryableName || "");
+        this.name = new queryable_string_js_1.QueryableString(queryableName || "");
         this.identifier = identifier;
         this.metadata = new Array();
         let metadataItem = null;
         // is named target
         if (typeof namedOrTagged === "string") {
-            metadataItem = new metadata_1.Metadata(METADATA_KEY.NAMED_TAG, namedOrTagged);
+            metadataItem = new metadata_js_1.Metadata(METADATA_KEY.NAMED_TAG, namedOrTagged);
         }
-        else if (namedOrTagged instanceof metadata_1.Metadata) {
+        else if (namedOrTagged instanceof metadata_js_1.Metadata) {
             // is target with metadata
             metadataItem = namedOrTagged;
         }

package/lib/cjs/di/resolution/instantiation.js

@@ -24,15 +24,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveInstance = resolveInstance;
-const error_msgs_1 = require("../constants/error_msgs");
-const literal_types_1 = require("../constants/literal_types");
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const async_1 = require("../utils/async");
+const error_msgs_js_1 = require("../constants/error_msgs.js");
+const literal_types_js_1 = require("../constants/literal_types.js");
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const async_js_1 = require("../utils/async.js");
 function _resolveRequests(childRequests, resolveRequest) {
     return childRequests.reduce((resolvedRequests, childRequest) => {
         const injection = resolveRequest(childRequest);
         const targetType = childRequest.target.type;
-        if (targetType === literal_types_1.TargetTypeEnum.ConstructorArgument) {
+        if (targetType === literal_types_js_1.TargetTypeEnum.ConstructorArgument) {
             resolvedRequests.constructorInjections.push(injection);
         }
         else {
@@ -40,7 +40,7 @@ function _resolveRequests(childRequests, resolveRequest) {
             resolvedRequests.propertyInjections.push(injection);
         }
         if (!resolvedRequests.isAsync) {
-            resolvedRequests.isAsync = (0, async_1.isPromiseOrContainsPromise)(injection);
+            resolvedRequests.isAsync = (0, async_js_1.isPromiseOrContainsPromise)(injection);
         }
         return resolvedRequests;
     }, {
@@ -104,7 +104,7 @@ async function possiblyWaitInjections(possiblePromiseinjections) {
 }
 function _getInstanceAfterPostConstruct(constr, result) {
     const postConstructResult = _postConstruct(constr, result);
-    if ((0, async_1.isPromise)(postConstructResult)) {
+    if ((0, async_js_1.isPromise)(postConstructResult)) {
         return postConstructResult.then(() => result);
     }
     else {
@@ -119,29 +119,29 @@ function _postConstruct(constr, instance) {
         }
         catch (e) {
             if (e instanceof Error) {
-                throw new Error((0, error_msgs_1.POST_CONSTRUCT_ERROR)(constr.name, e.message));
+                throw new Error((0, error_msgs_js_1.POST_CONSTRUCT_ERROR)(constr.name, e.message));
             }
         }
     }
 }
 function _validateInstanceResolution(binding, constr) {
-    if (binding.scope !== literal_types_1.BindingScopeEnum.Singleton) {
+    if (binding.scope !== literal_types_js_1.Scope.Singleton) {
         _throwIfHandlingDeactivation(binding, constr);
     }
 }
 function _throwIfHandlingDeactivation(binding, constr) {
-    const scopeErrorMessage = `Class cannot be instantiated in ${binding.scope === literal_types_1.BindingScopeEnum.Request ? "request" : "transient"} scope.`;
+    const scopeErrorMessage = `Class cannot be instantiated in ${binding.scope === literal_types_js_1.Scope.Request ? "request" : "transient"} scope.`;
     if (typeof binding.onDeactivation === "function") {
-        throw new Error((0, error_msgs_1.ON_DEACTIVATION_ERROR)(constr.name, scopeErrorMessage));
+        throw new Error((0, error_msgs_js_1.ON_DEACTIVATION_ERROR)(constr.name, scopeErrorMessage));
     }
     if (Reflect.hasMetadata(METADATA_KEY.PRE_DESTROY, constr)) {
-        throw new Error((0, error_msgs_1.PRE_DESTROY_ERROR)(constr.name, scopeErrorMessage));
+        throw new Error((0, error_msgs_js_1.PRE_DESTROY_ERROR)(constr.name, scopeErrorMessage));
     }
 }
 function resolveInstance(binding, constr, childRequests, resolveRequest) {
     _validateInstanceResolution(binding, constr);
     const result = _createInstance(constr, childRequests, resolveRequest);
-    if ((0, async_1.isPromise)(result)) {
+    if ((0, async_js_1.isPromise)(result)) {
         return result.then((resolvedResult) => _getInstanceAfterPostConstruct(constr, resolvedResult));
     }
     else {

package/lib/cjs/di/resolution/resolver.js

@@ -24,14 +24,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolve = resolve;
-const ERROR_MSGS = __importStar(require("../constants/error_msgs"));
-const literal_types_1 = require("../constants/literal_types");
-const planner_1 = require("../planning/planner");
-const scope_1 = require("../scope/scope");
-const async_1 = require("../utils/async");
-const binding_utils_1 = require("../utils/binding_utils");
-const exceptions_1 = require("../utils/exceptions");
-const instantiation_1 = require("./instantiation");
+const ERROR_MSGS = __importStar(require("../constants/error_msgs.js"));
+const literal_types_js_1 = require("../constants/literal_types.js");
+const planner_js_1 = require("../planning/planner.js");
+const scope_js_1 = require("../scope/scope.js");
+const async_js_1 = require("../utils/async.js");
+const binding_utils_js_1 = require("../utils/binding_utils.js");
+const exceptions_js_1 = require("../utils/exceptions.js");
+const instantiation_js_1 = require("./instantiation.js");
 const _resolveRequest = (requestScope) => (request) => {
     request.parentContext.setCurrentRequest(request);
     const bindings = request.bindings;
@@ -57,23 +57,23 @@ const _resolveRequest = (requestScope) => (request) => {
     }
 };
 const _resolveFactoryFromBinding = (binding, context) => {
-    const factoryDetails = (0, binding_utils_1.getFactoryDetails)(binding);
-    return (0, exceptions_1.tryAndThrowErrorIfStackOverflow)(() => factoryDetails.factory.bind(binding)(context), () => new Error(ERROR_MSGS.CIRCULAR_DEPENDENCY_IN_FACTORY(factoryDetails.factoryType, context.currentRequest.serviceIdentifier.toString())));
+    const factoryDetails = (0, binding_utils_js_1.getFactoryDetails)(binding);
+    return (0, exceptions_js_1.tryAndThrowErrorIfStackOverflow)(() => factoryDetails.factory.bind(binding)(context), () => new Error(ERROR_MSGS.CIRCULAR_DEPENDENCY_IN_FACTORY(factoryDetails.factoryType, context.currentRequest.serviceIdentifier.toString())));
 };
 const _getResolvedFromBinding = (requestScope, request, binding) => {
     let result;
     const childRequests = request.childRequests;
-    (0, binding_utils_1.ensureFullyBound)(binding);
+    (0, binding_utils_js_1.ensureFullyBound)(binding);
     switch (binding.type) {
-        case literal_types_1.BindingTypeEnum.ConstantValue:
-        case literal_types_1.BindingTypeEnum.Function:
+        case literal_types_js_1.BindingTypeEnum.ConstantValue:
+        case literal_types_js_1.BindingTypeEnum.Function:
             result = binding.cache;
             break;
-        case literal_types_1.BindingTypeEnum.Constructor:
+        case literal_types_js_1.BindingTypeEnum.Constructor:
             result = binding.implementationType;
             break;
-        case literal_types_1.BindingTypeEnum.Instance:
-            result = (0, instantiation_1.resolveInstance)(binding, binding.implementationType, childRequests, _resolveRequest(requestScope));
+        case literal_types_js_1.BindingTypeEnum.Instance:
+            result = (0, instantiation_js_1.resolveInstance)(binding, binding.implementationType, childRequests, _resolveRequest(requestScope));
             break;
         default:
             result = _resolveFactoryFromBinding(binding, request.parentContext);
@@ -81,18 +81,18 @@ const _getResolvedFromBinding = (requestScope, request, binding) => {
     return result;
 };
 const _resolveInScope = (requestScope, binding, resolveFromBinding) => {
-    let result = (0, scope_1.tryGetFromScope)(requestScope, binding);
+    let result = (0, scope_js_1.tryGetFromScope)(requestScope, binding);
     if (result !== null) {
         return result;
     }
     result = resolveFromBinding();
-    (0, scope_1.saveToScope)(requestScope, binding, result);
+    (0, scope_js_1.saveToScope)(requestScope, binding, result);
     return result;
 };
 const _resolveBinding = (requestScope, request, binding) => {
     return _resolveInScope(requestScope, binding, () => {
         let result = _getResolvedFromBinding(requestScope, request, binding);
-        if ((0, async_1.isPromise)(result)) {
+        if ((0, async_js_1.isPromise)(result)) {
             result = result.then((resolved) => _onActivation(request, binding, resolved));
         }
         else {
@@ -111,7 +111,7 @@ function _onActivation(request, binding, resolved) {
         const context = request.parentContext;
         const serviceIdentifier = request.serviceIdentifier;
         const activationsIterator = _getContainerActivationsForService(container, serviceIdentifier);
-        if ((0, async_1.isPromise)(result)) {
+        if ((0, async_js_1.isPromise)(result)) {
             result = _activateContainerAsync(activationsIterator, context, result);
         }
         else {
@@ -120,7 +120,7 @@ function _onActivation(request, binding, resolved) {
         containersIteratorResult = containersIterator.next();
         // make sure if we are currently on the container that owns the binding, not to keep looping down to child containers
     } while (containersIteratorResult.done !== true &&
-        !(0, planner_1.getBindingDictionary)(container).hasKey(request.serviceIdentifier));
+        !(0, planner_js_1.getBindingDictionary)(container).hasKey(request.serviceIdentifier));
     return result;
 }
 const _bindingActivation = (context, binding, previousResult) => {
@@ -138,7 +138,7 @@ const _activateContainer = (activationsIterator, context, result) => {
     let activation = activationsIterator.next();
     while (!activation.done) {
         result = activation.value(context, result);
-        if ((0, async_1.isPromise)(result)) {
+        if ((0, async_js_1.isPromise)(result)) {
             return _activateContainerAsync(activationsIterator, context, result);
         }
         activation = activationsIterator.next();

package/lib/cjs/di/scope/scope-registry.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalScopeRegistry = exports.ScopeRegistry = void 0;
+/**
+ * Registry for managing custom scope stores in dependency injection.
+ *
+ * @layer public
+ * @audience application-developers
+ * @concept scope-management
+ * @difficulty advanced
+ *
+ * @summary Quick Start
+ * Manages custom scope stores for multi-tenant or transaction-scoped services.
+ * Typically used internally by the framework.
+ *
+ * @example
+ * ```typescript
+ * const registry = new ScopeRegistry();
+ * const tenantScope = registry.getScopeStore("tenant");
+ * tenantScope.set(bindingId, instance);
+ * ```
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Architecture**
+ *
+ * ScopeRegistry maintains separate stores for each custom scope:
+ * - Each scope has its own Map of binding IDs to instances
+ * - Instances are cached per scope value
+ * - Used by InversifyJS container for custom scope resolution
+ *
+ * **Use Cases**
+ * - Multi-tenant applications (tenant scope)
+ * - Transaction management (transaction scope)
+ * - Workflow orchestration (workflow scope)
+ *
+ * @see {@link provideInScope} for registering services with custom scopes
+ *
+ * @public API
+ */
+class ScopeRegistry {
+    constructor() {
+        this.stores = new Map();
+    }
+    /**
+     * Get or create a scope store for the given scope name.
+     *
+     * @layer public
+     * @audience application-developers
+     *
+     * @param scopeName - The name of the custom scope (e.g., "tenant", "transaction")
+     * @returns The scope store Map for the given scope name
+     *
+     * @example
+     * ```typescript
+     * const registry = new ScopeRegistry();
+     * const tenantScope = registry.getScopeStore("tenant");
+     * // Use tenantScope to store/retrieve instances
+     * ```
+     *
+     * @public API
+     */
+    getScopeStore(scopeName) {
+        if (!this.stores.has(scopeName)) {
+            this.stores.set(scopeName, new Map());
+        }
+        return this.stores.get(scopeName);
+    }
+    /**
+     * Check if a scope store exists for the given scope name.
+     * @param scopeName - The name of the custom scope
+     * @returns True if the scope store exists, false otherwise
+     */
+    hasScope(scopeName) {
+        return this.stores.has(scopeName);
+    }
+    /**
+     * Clear all instances from a specific scope store.
+     * @param scopeName - The name of the custom scope to clear
+     */
+    clearScope(scopeName) {
+        const store = this.stores.get(scopeName);
+        if (store) {
+            store.clear();
+        }
+    }
+    /**
+     * Remove a scope store entirely.
+     * @param scopeName - The name of the custom scope to remove
+     */
+    removeScope(scopeName) {
+        this.stores.delete(scopeName);
+    }
+    /**
+     * Clear all scope stores.
+     */
+    clearAll() {
+        this.stores.clear();
+    }
+    /**
+     * Get all registered scope names.
+     * @returns Array of scope names
+     */
+    getScopeNames() {
+        return Array.from(this.stores.keys());
+    }
+}
+exports.ScopeRegistry = ScopeRegistry;
+/**
+ * Global scope registry instance.
+ * This is used by the container to manage custom scopes.
+ * @internal
+ */
+exports.globalScopeRegistry = new ScopeRegistry();

package/lib/cjs/di/scope/scope.js

@@ -1,25 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.saveToScope = exports.tryGetFromScope = void 0;
-const literal_types_1 = require("../constants/literal_types");
-const async_1 = require("../utils/async");
+const literal_types_js_1 = require("../constants/literal_types.js");
+const async_js_1 = require("../utils/async.js");
+const scope_registry_js_1 = require("./scope-registry.js");
+/**
+ * Check if a scope name is a built-in scope.
+ * @param scope - The scope name to check
+ * @returns True if it's a built-in scope, false otherwise
+ */
+const isBuiltInScope = (scope) => {
+    return (scope === literal_types_js_1.Scope.Singleton ||
+        scope === literal_types_js_1.Scope.Request ||
+        scope === literal_types_js_1.Scope.Transient);
+};
 const tryGetFromScope = (requestScope, binding) => {
-    if (binding.scope === literal_types_1.BindingScopeEnum.Singleton && binding.activated) {
+    // Handle Singleton scope
+    if (binding.scope === literal_types_js_1.Scope.Singleton && binding.activated) {
         return binding.cache;
     }
-    if (binding.scope === literal_types_1.BindingScopeEnum.Request &&
-        requestScope.has(binding.id)) {
+    // Handle Request scope
+    if (binding.scope === literal_types_js_1.Scope.Request && requestScope.has(binding.id)) {
         return requestScope.get(binding.id);
     }
+    // Handle custom scopes
+    if (!isBuiltInScope(binding.scope)) {
+        const customScopeStore = scope_registry_js_1.globalScopeRegistry.getScopeStore(binding.scope);
+        if (customScopeStore.has(binding.id)) {
+            return customScopeStore.get(binding.id);
+        }
+    }
     return null;
 };
 exports.tryGetFromScope = tryGetFromScope;
 const saveToScope = (requestScope, binding, result) => {
-    if (binding.scope === literal_types_1.BindingScopeEnum.Singleton) {
+    // Handle Singleton scope
+    if (binding.scope === literal_types_js_1.Scope.Singleton) {
         _saveToSingletonScope(binding, result);
+        return;
     }
-    if (binding.scope === literal_types_1.BindingScopeEnum.Request) {
+    // Handle Request scope
+    if (binding.scope === literal_types_js_1.Scope.Request) {
         _saveToRequestScope(requestScope, binding, result);
+        return;
+    }
+    // Handle custom scopes
+    if (!isBuiltInScope(binding.scope)) {
+        const customScopeStore = scope_registry_js_1.globalScopeRegistry.getScopeStore(binding.scope);
+        if (!customScopeStore.has(binding.id)) {
+            customScopeStore.set(binding.id, result);
+        }
     }
 };
 exports.saveToScope = saveToScope;
@@ -32,7 +62,7 @@ const _saveToSingletonScope = (binding, result) => {
     // store in cache if scope is singleton
     binding.cache = result;
     binding.activated = true;
-    if ((0, async_1.isPromise)(result)) {
+    if ((0, async_js_1.isPromise)(result)) {
         void _saveAsyncResultToSingletonScope(binding, result);
     }
 };