@expressots/core 3.0.0 → 4.0.0-preview.3

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

@@ -0,0 +1,125 @@
+import { ON_DEACTIVATION_ERROR, POST_CONSTRUCT_ERROR, PRE_DESTROY_ERROR, } from "../constants/error_msgs.js";
+import { Scope, TargetTypeEnum } from "../constants/literal_types.js";
+import * as METADATA_KEY from "../constants/metadata_keys.js";
+import { isPromise, isPromiseOrContainsPromise } from "../utils/async.js";
+function _resolveRequests(childRequests, resolveRequest) {
+    return childRequests.reduce((resolvedRequests, childRequest) => {
+        const injection = resolveRequest(childRequest);
+        const targetType = childRequest.target.type;
+        if (targetType === TargetTypeEnum.ConstructorArgument) {
+            resolvedRequests.constructorInjections.push(injection);
+        }
+        else {
+            resolvedRequests.propertyRequests.push(childRequest);
+            resolvedRequests.propertyInjections.push(injection);
+        }
+        if (!resolvedRequests.isAsync) {
+            resolvedRequests.isAsync = isPromiseOrContainsPromise(injection);
+        }
+        return resolvedRequests;
+    }, {
+        constructorInjections: [],
+        propertyInjections: [],
+        propertyRequests: [],
+        isAsync: false,
+    });
+}
+function _createInstance(constr, childRequests, resolveRequest) {
+    let result;
+    if (childRequests.length > 0) {
+        const resolved = _resolveRequests(childRequests, resolveRequest);
+        const createInstanceWithInjectionsArg = {
+            ...resolved,
+            constr,
+        };
+        if (resolved.isAsync) {
+            result = createInstanceWithInjectionsAsync(createInstanceWithInjectionsArg);
+        }
+        else {
+            result = createInstanceWithInjections(createInstanceWithInjectionsArg);
+        }
+    }
+    else {
+        result = new constr();
+    }
+    return result;
+}
+function createInstanceWithInjections(args) {
+    const instance = new args.constr(...args.constructorInjections);
+    args.propertyRequests.forEach((r, index) => {
+        const property = r.target.identifier;
+        const injection = args.propertyInjections[index];
+        if (!r.target.isOptional() || injection !== undefined) {
+            instance[property] = injection;
+        }
+    });
+    return instance;
+}
+async function createInstanceWithInjectionsAsync(args) {
+    const constructorInjections = await possiblyWaitInjections(args.constructorInjections);
+    const propertyInjections = await possiblyWaitInjections(args.propertyInjections);
+    return createInstanceWithInjections({
+        ...args,
+        constructorInjections,
+        propertyInjections,
+    });
+}
+async function possiblyWaitInjections(possiblePromiseinjections) {
+    const injections = [];
+    for (const injection of possiblePromiseinjections) {
+        if (Array.isArray(injection)) {
+            injections.push(Promise.all(injection));
+        }
+        else {
+            injections.push(injection);
+        }
+    }
+    return Promise.all(injections);
+}
+function _getInstanceAfterPostConstruct(constr, result) {
+    const postConstructResult = _postConstruct(constr, result);
+    if (isPromise(postConstructResult)) {
+        return postConstructResult.then(() => result);
+    }
+    else {
+        return result;
+    }
+}
+function _postConstruct(constr, instance) {
+    if (Reflect.hasMetadata(METADATA_KEY.POST_CONSTRUCT, constr)) {
+        const data = Reflect.getMetadata(METADATA_KEY.POST_CONSTRUCT, constr);
+        try {
+            return instance[data.value]?.();
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                throw new Error(POST_CONSTRUCT_ERROR(constr.name, e.message));
+            }
+        }
+    }
+}
+function _validateInstanceResolution(binding, constr) {
+    if (binding.scope !== Scope.Singleton) {
+        _throwIfHandlingDeactivation(binding, constr);
+    }
+}
+function _throwIfHandlingDeactivation(binding, constr) {
+    const scopeErrorMessage = `Class cannot be instantiated in ${binding.scope === Scope.Request ? "request" : "transient"} scope.`;
+    if (typeof binding.onDeactivation === "function") {
+        throw new Error(ON_DEACTIVATION_ERROR(constr.name, scopeErrorMessage));
+    }
+    if (Reflect.hasMetadata(METADATA_KEY.PRE_DESTROY, constr)) {
+        throw new Error(PRE_DESTROY_ERROR(constr.name, scopeErrorMessage));
+    }
+}
+function resolveInstance(binding, constr, childRequests, resolveRequest) {
+    _validateInstanceResolution(binding, constr);
+    const result = _createInstance(constr, childRequests, resolveRequest);
+    if (isPromise(result)) {
+        return result.then((resolvedResult) => _getInstanceAfterPostConstruct(constr, resolvedResult));
+    }
+    else {
+        return _getInstanceAfterPostConstruct(constr, result);
+    }
+}
+export { resolveInstance };

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

@@ -0,0 +1,163 @@
+import * as ERROR_MSGS from "../constants/error_msgs.js";
+import { BindingTypeEnum } from "../constants/literal_types.js";
+import { getBindingDictionary } from "../planning/planner.js";
+import { saveToScope, tryGetFromScope } from "../scope/scope.js";
+import { isPromise } from "../utils/async.js";
+import { getFactoryDetails, ensureFullyBound } from "../utils/binding_utils.js";
+import { tryAndThrowErrorIfStackOverflow } from "../utils/exceptions.js";
+import { resolveInstance } from "./instantiation.js";
+const _resolveRequest = (requestScope) => (request) => {
+    request.parentContext.setCurrentRequest(request);
+    const bindings = request.bindings;
+    const childRequests = request.childRequests;
+    const targetIsAnArray = request.target && request.target.isArray();
+    const targetParentIsNotAnArray = !request.parentRequest ||
+        !request.parentRequest.target ||
+        !request.target ||
+        !request.parentRequest.target.matchesArray(request.target.serviceIdentifier);
+    if (targetIsAnArray && targetParentIsNotAnArray) {
+        // Create an array instead of creating an instance
+        return childRequests.map((childRequest) => {
+            const _f = _resolveRequest(requestScope);
+            return _f(childRequest);
+        });
+    }
+    else {
+        if (request.target.isOptional() && bindings.length === 0) {
+            return undefined;
+        }
+        const binding = bindings[0];
+        return _resolveBinding(requestScope, request, binding);
+    }
+};
+const _resolveFactoryFromBinding = (binding, context) => {
+    const factoryDetails = getFactoryDetails(binding);
+    return 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;
+    ensureFullyBound(binding);
+    switch (binding.type) {
+        case BindingTypeEnum.ConstantValue:
+        case BindingTypeEnum.Function:
+            result = binding.cache;
+            break;
+        case BindingTypeEnum.Constructor:
+            result = binding.implementationType;
+            break;
+        case BindingTypeEnum.Instance:
+            result = resolveInstance(binding, binding.implementationType, childRequests, _resolveRequest(requestScope));
+            break;
+        default:
+            result = _resolveFactoryFromBinding(binding, request.parentContext);
+    }
+    return result;
+};
+const _resolveInScope = (requestScope, binding, resolveFromBinding) => {
+    let result = tryGetFromScope(requestScope, binding);
+    if (result !== null) {
+        return result;
+    }
+    result = resolveFromBinding();
+    saveToScope(requestScope, binding, result);
+    return result;
+};
+const _resolveBinding = (requestScope, request, binding) => {
+    return _resolveInScope(requestScope, binding, () => {
+        let result = _getResolvedFromBinding(requestScope, request, binding);
+        if (isPromise(result)) {
+            result = result.then((resolved) => _onActivation(request, binding, resolved));
+        }
+        else {
+            result = _onActivation(request, binding, result);
+        }
+        return result;
+    });
+};
+function _onActivation(request, binding, resolved) {
+    let result = _bindingActivation(request.parentContext, binding, resolved);
+    const containersIterator = _getContainersIterator(request.parentContext.container);
+    let container;
+    let containersIteratorResult = containersIterator.next();
+    do {
+        container = containersIteratorResult.value;
+        const context = request.parentContext;
+        const serviceIdentifier = request.serviceIdentifier;
+        const activationsIterator = _getContainerActivationsForService(container, serviceIdentifier);
+        if (isPromise(result)) {
+            result = _activateContainerAsync(activationsIterator, context, result);
+        }
+        else {
+            result = _activateContainer(activationsIterator, context, result);
+        }
+        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 &&
+        !getBindingDictionary(container).hasKey(request.serviceIdentifier));
+    return result;
+}
+const _bindingActivation = (context, binding, previousResult) => {
+    let result;
+    // use activation handler if available
+    if (typeof binding.onActivation === "function") {
+        result = binding.onActivation(context, previousResult);
+    }
+    else {
+        result = previousResult;
+    }
+    return result;
+};
+const _activateContainer = (activationsIterator, context, result) => {
+    let activation = activationsIterator.next();
+    while (!activation.done) {
+        result = activation.value(context, result);
+        if (isPromise(result)) {
+            return _activateContainerAsync(activationsIterator, context, result);
+        }
+        activation = activationsIterator.next();
+    }
+    return result;
+};
+const _activateContainerAsync = async (activationsIterator, context, resultPromise) => {
+    let result = await resultPromise;
+    let activation = activationsIterator.next();
+    while (!activation.done) {
+        result = await activation.value(context, result);
+        activation = activationsIterator.next();
+    }
+    return result;
+};
+const _getContainerActivationsForService = (container, serviceIdentifier) => {
+    // smell accessing _activations, but similar pattern is done in planner.getBindingDictionary()
+    const activations = container._activations;
+    return activations.hasKey(serviceIdentifier)
+        ? activations.get(serviceIdentifier).values()
+        : [].values();
+};
+const _getContainersIterator = (container) => {
+    const containersStack = [container];
+    let parent = container.parent;
+    while (parent !== null) {
+        containersStack.push(parent);
+        parent = parent.parent;
+    }
+    const getNextContainer = () => {
+        const nextContainer = containersStack.pop();
+        if (nextContainer !== undefined) {
+            return { done: false, value: nextContainer };
+        }
+        else {
+            return { done: true, value: undefined };
+        }
+    };
+    const containersIterator = {
+        next: getNextContainer,
+    };
+    return containersIterator;
+};
+function resolve(context) {
+    const _f = _resolveRequest(context.plan.rootRequest.requestScope);
+    return _f(context.plan.rootRequest);
+}
+export { resolve };

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

@@ -0,0 +1,109 @@
+/**
+ * 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
+ */
+export class ScopeRegistry {
+    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());
+    }
+}
+/**
+ * Global scope registry instance.
+ * This is used by the container to manage custom scopes.
+ * @internal
+ */
+export const globalScopeRegistry = new ScopeRegistry();

package/lib/esm/di/scope/scope.js

@@ -0,0 +1,75 @@
+import { Scope } from "../constants/literal_types.js";
+import { isPromise } from "../utils/async.js";
+import { globalScopeRegistry } from "./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 === Scope.Singleton ||
+        scope === Scope.Request ||
+        scope === Scope.Transient);
+};
+export const tryGetFromScope = (requestScope, binding) => {
+    // Handle Singleton scope
+    if (binding.scope === Scope.Singleton && binding.activated) {
+        return binding.cache;
+    }
+    // Handle Request scope
+    if (binding.scope === Scope.Request && requestScope.has(binding.id)) {
+        return requestScope.get(binding.id);
+    }
+    // Handle custom scopes
+    if (!isBuiltInScope(binding.scope)) {
+        const customScopeStore = globalScopeRegistry.getScopeStore(binding.scope);
+        if (customScopeStore.has(binding.id)) {
+            return customScopeStore.get(binding.id);
+        }
+    }
+    return null;
+};
+export const saveToScope = (requestScope, binding, result) => {
+    // Handle Singleton scope
+    if (binding.scope === Scope.Singleton) {
+        _saveToSingletonScope(binding, result);
+        return;
+    }
+    // Handle Request scope
+    if (binding.scope === Scope.Request) {
+        _saveToRequestScope(requestScope, binding, result);
+        return;
+    }
+    // Handle custom scopes
+    if (!isBuiltInScope(binding.scope)) {
+        const customScopeStore = globalScopeRegistry.getScopeStore(binding.scope);
+        if (!customScopeStore.has(binding.id)) {
+            customScopeStore.set(binding.id, result);
+        }
+    }
+};
+const _saveToRequestScope = (requestScope, binding, result) => {
+    if (!requestScope.has(binding.id)) {
+        requestScope.set(binding.id, result);
+    }
+};
+const _saveToSingletonScope = (binding, result) => {
+    // store in cache if scope is singleton
+    binding.cache = result;
+    binding.activated = true;
+    if (isPromise(result)) {
+        void _saveAsyncResultToSingletonScope(binding, result);
+    }
+};
+const _saveAsyncResultToSingletonScope = async (binding, asyncResult) => {
+    try {
+        const result = await asyncResult;
+        binding.cache = result;
+    }
+    catch (ex) {
+        // allow binding to retry in future
+        binding.cache = null;
+        binding.activated = false;
+        throw ex;
+    }
+};

package/lib/esm/di/syntax/binding_in_syntax.js

@@ -0,0 +1,31 @@
+import { Scope } from "../constants/literal_types.js";
+import { BindingWhenOnSyntax } from "./binding_when_on_syntax.js";
+class BindingInSyntax {
+    _binding;
+    constructor(binding) {
+        this._binding = binding;
+    }
+    inRequestScope() {
+        this._binding.scope = Scope.Request;
+        return new BindingWhenOnSyntax(this._binding);
+    }
+    inSingletonScope() {
+        this._binding.scope = Scope.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    }
+    inTransientScope() {
+        this._binding.scope = Scope.Transient;
+        return new BindingWhenOnSyntax(this._binding);
+    }
+    inScope(scope) {
+        // Validate that custom scope name doesn't conflict with built-in scopes
+        if (scope === Scope.Singleton ||
+            scope === Scope.Request ||
+            scope === Scope.Transient) {
+            throw new Error(`Cannot use built-in scope name "${scope}" as custom scope. Use the corresponding method instead (e.g., inSingletonScope()).`);
+        }
+        this._binding.scope = scope;
+        return new BindingWhenOnSyntax(this._binding);
+    }
+}
+export { BindingInSyntax };

package/lib/esm/di/syntax/binding_in_when_on_syntax.js

@@ -0,0 +1,79 @@
+import { BindingInSyntax } from "./binding_in_syntax.js";
+import { BindingOnSyntax } from "./binding_on_syntax.js";
+import { BindingWhenSyntax } from "./binding_when_syntax.js";
+class BindingInWhenOnSyntax {
+    _bindingInSyntax;
+    _bindingWhenSyntax;
+    _bindingOnSyntax;
+    _binding;
+    constructor(binding) {
+        this._binding = binding;
+        this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
+        this._bindingOnSyntax = new BindingOnSyntax(this._binding);
+        this._bindingInSyntax = new BindingInSyntax(binding);
+    }
+    inRequestScope() {
+        return this._bindingInSyntax.inRequestScope();
+    }
+    inSingletonScope() {
+        return this._bindingInSyntax.inSingletonScope();
+    }
+    inTransientScope() {
+        return this._bindingInSyntax.inTransientScope();
+    }
+    inScope(scope) {
+        return this._bindingInSyntax.inScope(scope);
+    }
+    when(constraint) {
+        return this._bindingWhenSyntax.when(constraint);
+    }
+    whenTargetNamed(name) {
+        return this._bindingWhenSyntax.whenTargetNamed(name);
+    }
+    whenTargetIsDefault() {
+        return this._bindingWhenSyntax.whenTargetIsDefault();
+    }
+    whenTargetTagged(tag, value) {
+        return this._bindingWhenSyntax.whenTargetTagged(tag, value);
+    }
+    whenInjectedInto(parent) {
+        return this._bindingWhenSyntax.whenInjectedInto(parent);
+    }
+    whenParentNamed(name) {
+        return this._bindingWhenSyntax.whenParentNamed(name);
+    }
+    whenParentTagged(tag, value) {
+        return this._bindingWhenSyntax.whenParentTagged(tag, value);
+    }
+    whenAnyAncestorIs(ancestor) {
+        return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
+    }
+    whenNoAncestorIs(ancestor) {
+        return this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
+    }
+    whenAnyAncestorNamed(name) {
+        return this._bindingWhenSyntax.whenAnyAncestorNamed(name);
+    }
+    whenAnyAncestorTagged(tag, value) {
+        return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
+    }
+    whenNoAncestorNamed(name) {
+        return this._bindingWhenSyntax.whenNoAncestorNamed(name);
+    }
+    whenNoAncestorTagged(tag, value) {
+        return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);
+    }
+    whenAnyAncestorMatches(constraint) {
+        return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);
+    }
+    whenNoAncestorMatches(constraint) {
+        return this._bindingWhenSyntax.whenNoAncestorMatches(constraint);
+    }
+    onActivation(handler) {
+        return this._bindingOnSyntax.onActivation(handler);
+    }
+    onDeactivation(handler) {
+        return this._bindingOnSyntax.onDeactivation(handler);
+    }
+}
+export { BindingInWhenOnSyntax };

package/lib/esm/di/syntax/binding_on_syntax.js

@@ -0,0 +1,16 @@
+import { BindingWhenSyntax } from "./binding_when_syntax.js";
+class BindingOnSyntax {
+    _binding;
+    constructor(binding) {
+        this._binding = binding;
+    }
+    onActivation(handler) {
+        this._binding.onActivation = handler;
+        return new BindingWhenSyntax(this._binding);
+    }
+    onDeactivation(handler) {
+        this._binding.onDeactivation = handler;
+        return new BindingWhenSyntax(this._binding);
+    }
+}
+export { BindingOnSyntax };

package/lib/esm/di/syntax/binding_to_syntax.js

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import * as ERROR_MSGS from "../constants/error_msgs.js";
+import { Scope, BindingTypeEnum } from "../constants/literal_types.js";
+import { BindingInWhenOnSyntax } from "./binding_in_when_on_syntax.js";
+import { BindingWhenOnSyntax } from "./binding_when_on_syntax.js";
+class BindingToSyntax {
+    // TODO: Implement an internal type `_BindingToSyntax<T>` wherein this member
+    // can be public. Let `BindingToSyntax<T>` be the presentational type that
+    // depends on it, and does not expose this member as public.
+    _binding;
+    constructor(binding) {
+        this._binding = binding;
+    }
+    to(constructor) {
+        this._binding.type = BindingTypeEnum.Instance;
+        this._binding.implementationType = constructor;
+        return new BindingInWhenOnSyntax(this._binding);
+    }
+    toSelf() {
+        if (typeof this._binding.serviceIdentifier !== "function") {
+            throw new Error(`${ERROR_MSGS.INVALID_TO_SELF_VALUE}`);
+        }
+        const self = this._binding.serviceIdentifier;
+        return this.to(self);
+    }
+    toConstantValue(value) {
+        this._binding.type = BindingTypeEnum.ConstantValue;
+        this._binding.cache = value;
+        this._binding.dynamicValue = null;
+        this._binding.implementationType = null;
+        this._binding.scope = Scope.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    }
+    toDynamicValue(func) {
+        this._binding.type = BindingTypeEnum.DynamicValue;
+        this._binding.cache = null;
+        this._binding.dynamicValue = func;
+        this._binding.implementationType = null;
+        return new BindingInWhenOnSyntax(this._binding);
+    }
+    toConstructor(constructor) {
+        this._binding.type = BindingTypeEnum.Constructor;
+        this._binding.implementationType = constructor;
+        this._binding.scope = Scope.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    }
+    toFactory(factory) {
+        this._binding.type = BindingTypeEnum.Factory;
+        this._binding.factory = factory;
+        this._binding.scope = Scope.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    }
+    toFunction(func) {
+        // toFunction is an alias of toConstantValue
+        if (typeof func !== "function") {
+            throw new Error(ERROR_MSGS.INVALID_FUNCTION_BINDING);
+        }
+        const bindingWhenOnSyntax = this.toConstantValue(func);
+        this._binding.type = BindingTypeEnum.Function;
+        this._binding.scope = Scope.Singleton;
+        return bindingWhenOnSyntax;
+    }
+    toAutoFactory(serviceIdentifier) {
+        this._binding.type = BindingTypeEnum.Factory;
+        this._binding.factory = (context) => {
+            const autofactory = () => context.container.get(serviceIdentifier);
+            return autofactory;
+        };
+        this._binding.scope = Scope.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    }
+    toAutoNamedFactory(serviceIdentifier) {
+        this._binding.type = BindingTypeEnum.Factory;
+        this._binding.factory = (context) => {
+            return (named) => context.container.getNamed(serviceIdentifier, named);
+        };
+        return new BindingWhenOnSyntax(this._binding);
+    }
+    toProvider(provider) {
+        this._binding.type = BindingTypeEnum.Provider;
+        this._binding.provider = provider;
+        this._binding.scope = Scope.Singleton;
+        return new BindingWhenOnSyntax(this._binding);
+    }
+    toService(service) {
+        this.toDynamicValue((context) => context.container.get(service));
+    }
+}
+export { BindingToSyntax };