@venok/core 1.0.0

package/injector/injector.d.ts

@@ -0,0 +1,87 @@
+import { InjectionToken } from "@venok/core/interfaces/modules";
+import { ContextId, InstancePerContext, InstanceWrapper, PropertyMetadata } from "@venok/core/injector/instance/wrapper";
+import { Module } from "@venok/core/injector/module/module";
+import { Type } from "@venok/core/interfaces";
+import { SettlementSignal } from "@venok/core/injector/settlement-signal";
+import { Injectable } from "@venok/core/interfaces/injectable.interface";
+/**
+ * The type of injectable dependency
+ */
+export type InjectorDependency = InjectionToken;
+/**
+ * The property-based dependency
+ */
+export interface PropertyDependency {
+    key: symbol | string;
+    name: InjectorDependency;
+    isOptional?: boolean;
+    instance?: any;
+}
+/**
+ * Context of a dependency which gets injected by
+ * the injector
+ */
+export interface InjectorDependencyContext {
+    /**
+     * The name of the property key (property-based injection)
+     */
+    key?: string | symbol;
+    /**
+     * The function itself, the name of the function, or injection token.
+     */
+    name?: Function | string | symbol;
+    /**
+     * The index of the dependency which gets injected
+     * from the dependencies array
+     */
+    index?: number;
+    /**
+     * The dependency array which gets injected
+     */
+    dependencies?: InjectorDependency[];
+}
+export declare class Injector {
+    private readonly options?;
+    private logger;
+    constructor(options?: {
+        preview: boolean;
+    } | undefined);
+    loadPrototype<T>({ token }: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper<T>>, contextId?: ContextId): void;
+    loadInstance<T>(wrapper: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadInjectable<T = any>(wrapper: InstanceWrapper<T>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadProvider(wrapper: InstanceWrapper<Injectable>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    applySettlementSignal<T>(instancePerContext: InstancePerContext<T>, host: InstanceWrapper<T>): SettlementSignal;
+    resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, moduleRef: Module, inject: InjectorDependency[] | null, callback: (args: unknown[]) => void | Promise<void>, contextId?: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<void>;
+    getClassDependencies<T>(wrapper: InstanceWrapper<T>): [InjectorDependency[], number[]];
+    getFactoryProviderDependencies<T>(wrapper: InstanceWrapper<T>): [InjectorDependency[], number[]];
+    reflectConstructorParams<T>(type: Type<T>): any[];
+    reflectOptionalParams<T>(type: Type<T>): any[];
+    reflectSelfParams<T>(type: Type<T>): any[];
+    resolveSingleParam<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol | any, dependencyContext: InjectorDependencyContext, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<any>>;
+    resolveParamToken<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol | any): any;
+    resolveComponentInstance<T>(moduleRef: Module, token: InjectionToken, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper>;
+    resolveComponentHost<T>(moduleRef: Module, instanceWrapper: InstanceWrapper<T | Promise<T>>, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<InstanceWrapper>;
+    lookupComponent<T = any>(providers: Map<Function | string | symbol, InstanceWrapper>, moduleRef: Module, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<T>>;
+    lookupComponentInParentModules<T = any>(dependencyContext: InjectorDependencyContext, moduleRef: Module, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<any>;
+    lookupComponentInImports(moduleRef: Module, name: InjectionToken, wrapper: InstanceWrapper, moduleRegistry?: any[], contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number, isTraversing?: boolean): Promise<any>;
+    resolveProperties<T>(wrapper: InstanceWrapper<T>, moduleRef: Module, inject?: InjectorDependency[], contextId?: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<PropertyDependency[]>;
+    reflectProperties<T>(type: Type<T>): PropertyDependency[];
+    applyProperties<T = any>(instance: T, properties: PropertyDependency[]): void;
+    instantiateClass<T = any>(instances: any[], wrapper: InstanceWrapper, targetMetatype: InstanceWrapper, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<T>;
+    loadPerContext<T = any>(instance: T, moduleRef: Module, collection: Map<InjectionToken, InstanceWrapper>, ctx: ContextId, wrapper?: InstanceWrapper): Promise<T>;
+    loadEnhancersPerContext(wrapper: InstanceWrapper, ctx: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadCtorMetadata(metadata: InstanceWrapper<any>[], contextId: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<any[]>;
+    loadPropertiesMetadata(metadata: PropertyMetadata[], contextId: ContextId, inquirer?: InstanceWrapper): Promise<PropertyDependency[]>;
+    private getInquirerId;
+    private resolveScopedComponentHost;
+    private isInquirerRequest;
+    private isInquirer;
+    protected addDependencyMetadata(keyOrIndex: symbol | string | number, hostWrapper: InstanceWrapper, instanceWrapper: InstanceWrapper): void;
+    private getTokenName;
+    private printResolvingDependenciesLog;
+    private printLookingForProviderLog;
+    private printFoundInModuleLog;
+    private isDebugMode;
+    private getContextId;
+    private getNowTimestamp;
+}

package/injector/injector.js

@@ -0,0 +1,452 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injector = void 0;
+const wrapper_1 = require("@venok/core/injector/instance/wrapper");
+const constants_1 = require("@venok/core/injector/constants");
+const logger_service_1 = require("@venok/core/services/logger.service");
+const exceptions_1 = require("@venok/core/errors/exceptions");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const settlement_signal_1 = require("@venok/core/injector/settlement-signal");
+const constants_2 = require("@venok/core/constants");
+const undefined_dependency_exception_1 = require("@venok/core/errors/exceptions/undefined-dependency.exception");
+const unknown_dependencies_exception_1 = require("@venok/core/errors/exceptions/unknown-dependencies.exception");
+const color_helper_1 = require("@venok/core/helpers/color.helper");
+class Injector {
+    constructor(options) {
+        this.options = options;
+        this.logger = new logger_service_1.Logger("InjectorLogger");
+    }
+    loadPrototype({ token }, collection, contextId = constants_1.STATIC_CONTEXT) {
+        if (!collection) {
+            return;
+        }
+        const target = collection.get(token);
+        const instance = target.createPrototype(contextId);
+        if (instance) {
+            const wrapper = new wrapper_1.InstanceWrapper({
+                ...target,
+                instance,
+            });
+            collection.set(token, wrapper);
+        }
+    }
+    async loadInstance(wrapper, collection, moduleRef, contextId = constants_1.STATIC_CONTEXT, inquirer) {
+        const inquirerId = this.getInquirerId(inquirer);
+        const instanceHost = wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId);
+        // Maybe Error
+        if (instanceHost.isPending && instanceHost.donePromise) {
+            const settlementSignal = wrapper.settlementSignal;
+            if (inquirer && settlementSignal?.isCycle(inquirer.id))
+                throw new exceptions_1.CircularDependencyException(`"${wrapper.name}"`);
+            return instanceHost.donePromise.then((err) => {
+                if (err)
+                    throw err;
+            });
+        }
+        const settlementSignal = this.applySettlementSignal(instanceHost, wrapper);
+        const token = wrapper.token || wrapper.name;
+        const { inject } = wrapper;
+        const targetWrapper = collection.get(token);
+        if ((0, shared_helper_1.isUndefined)(targetWrapper)) {
+            throw new exceptions_1.RuntimeException();
+        }
+        if (instanceHost.isResolved) {
+            return settlementSignal.complete();
+        }
+        try {
+            const t0 = this.getNowTimestamp();
+            const callback = async (instances) => {
+                const properties = await this.resolveProperties(wrapper, moduleRef, inject, contextId, wrapper, inquirer);
+                const instance = await this.instantiateClass(instances, wrapper, targetWrapper, contextId, inquirer);
+                this.applyProperties(instance, properties);
+                wrapper.initTime = this.getNowTimestamp() - t0;
+                settlementSignal.complete();
+            };
+            await this.resolveConstructorParams(wrapper, moduleRef, inject, callback, contextId, wrapper, inquirer);
+        }
+        catch (err) {
+            settlementSignal.error(err);
+            throw err;
+        }
+    }
+    async loadInjectable(wrapper, moduleRef, contextId = constants_1.STATIC_CONTEXT, inquirer) {
+        const injectables = moduleRef.injectables;
+        await this.loadInstance(wrapper, injectables, moduleRef, contextId, inquirer);
+    }
+    async loadProvider(wrapper, moduleRef, contextId = constants_1.STATIC_CONTEXT, inquirer) {
+        const providers = moduleRef.providers;
+        await this.loadInstance(wrapper, providers, moduleRef, contextId, inquirer);
+        await this.loadEnhancersPerContext(wrapper, contextId, wrapper);
+    }
+    applySettlementSignal(instancePerContext, host) {
+        const settlementSignal = new settlement_signal_1.SettlementSignal();
+        instancePerContext.donePromise = settlementSignal.asPromise();
+        instancePerContext.isPending = true;
+        host.settlementSignal = settlementSignal;
+        return settlementSignal;
+    }
+    async resolveConstructorParams(wrapper, moduleRef, inject, callback, contextId = constants_1.STATIC_CONTEXT, inquirer, parentInquirer) {
+        let inquirerId = this.getInquirerId(inquirer);
+        const metadata = wrapper.getCtorMetadata();
+        if (metadata && contextId !== constants_1.STATIC_CONTEXT) {
+            const deps = await this.loadCtorMetadata(metadata, contextId, inquirer, parentInquirer);
+            return callback(deps);
+        }
+        const isFactoryProvider = !(0, shared_helper_1.isNull)(inject);
+        const [dependencies, optionalDependenciesIds] = isFactoryProvider
+            ? this.getFactoryProviderDependencies(wrapper)
+            : this.getClassDependencies(wrapper);
+        let isResolved = true;
+        const resolveParam = async (param, index) => {
+            try {
+                if (this.isInquirer(param, parentInquirer)) {
+                    return parentInquirer && parentInquirer.instance;
+                }
+                if (inquirer?.isTransient && parentInquirer) {
+                    inquirer = parentInquirer;
+                    inquirerId = this.getInquirerId(parentInquirer);
+                }
+                const paramWrapper = await this.resolveSingleParam(wrapper, param, { index, dependencies }, moduleRef, contextId, inquirer, index);
+                const instanceHost = paramWrapper.getInstanceByContextId(this.getContextId(contextId, paramWrapper), inquirerId);
+                if (!instanceHost.isResolved && !paramWrapper.forwardRef) {
+                    isResolved = false;
+                }
+                return instanceHost?.instance;
+            }
+            catch (err) {
+                const isOptional = optionalDependenciesIds.includes(index);
+                if (!isOptional) {
+                    throw err;
+                }
+                return undefined;
+            }
+        };
+        const instances = await Promise.all(dependencies.map(resolveParam));
+        isResolved && (await callback(instances));
+    }
+    getClassDependencies(wrapper) {
+        const ctorRef = wrapper.metatype;
+        return [this.reflectConstructorParams(ctorRef), this.reflectOptionalParams(ctorRef)];
+    }
+    getFactoryProviderDependencies(wrapper) {
+        const optionalDependenciesIds = [];
+        const isOptionalFactoryDep = (item) => !(0, shared_helper_1.isUndefined)(item.token) &&
+            !(0, shared_helper_1.isUndefined)(item.optional);
+        const mapFactoryProviderInjectArray = (item, index) => {
+            if (typeof item !== "object") {
+                return item;
+            }
+            if (isOptionalFactoryDep(item)) {
+                if (item.optional)
+                    optionalDependenciesIds.push(index);
+                return item?.token;
+            }
+            return item;
+        };
+        return [wrapper.inject?.map?.(mapFactoryProviderInjectArray), optionalDependenciesIds];
+    }
+    reflectConstructorParams(type) {
+        const paramtypes = [...(Reflect.getMetadata(constants_2.PARAMTYPES_METADATA, type) || [])];
+        const selfParams = this.reflectSelfParams(type);
+        selfParams.forEach(({ index, param }) => (paramtypes[index] = param));
+        return paramtypes;
+    }
+    reflectOptionalParams(type) {
+        return Reflect.getMetadata(constants_2.OPTIONAL_DEPS_METADATA, type) || [];
+    }
+    reflectSelfParams(type) {
+        return Reflect.getMetadata(constants_2.SELF_DECLARED_DEPS_METADATA, type) || [];
+    }
+    async resolveSingleParam(wrapper, param, dependencyContext, moduleRef, contextId = constants_1.STATIC_CONTEXT, inquirer, keyOrIndex) {
+        if ((0, shared_helper_1.isUndefined)(param)) {
+            this.logger.log("Venok encountered an undefined dependency. This may be due to a circular import or a missing dependency declaration.");
+            throw new undefined_dependency_exception_1.UndefinedDependencyException(wrapper.name, dependencyContext, moduleRef);
+        }
+        const token = this.resolveParamToken(wrapper, param);
+        return this.resolveComponentInstance(moduleRef, token, dependencyContext, wrapper, contextId, inquirer, keyOrIndex);
+    }
+    resolveParamToken(wrapper, param) {
+        if (!param.forwardRef) {
+            return param;
+        }
+        wrapper.forwardRef = true;
+        return param.forwardRef();
+    }
+    async resolveComponentInstance(moduleRef, token, dependencyContext, wrapper, contextId = constants_1.STATIC_CONTEXT, inquirer, keyOrIndex) {
+        this.printResolvingDependenciesLog(token, inquirer);
+        this.printLookingForProviderLog(token, moduleRef);
+        const providers = moduleRef.providers;
+        const instanceWrapper = await this.lookupComponent(providers, moduleRef, { ...dependencyContext, name: token }, wrapper, contextId, inquirer, keyOrIndex);
+        return this.resolveComponentHost(moduleRef, instanceWrapper, contextId, inquirer);
+    }
+    async resolveComponentHost(moduleRef, instanceWrapper, contextId = constants_1.STATIC_CONTEXT, inquirer) {
+        const inquirerId = this.getInquirerId(inquirer);
+        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+        if (!instanceHost.isResolved && !instanceWrapper.forwardRef) {
+            inquirer?.settlementSignal?.insertRef(instanceWrapper.id);
+            await this.loadProvider(instanceWrapper, instanceWrapper.host ?? moduleRef, contextId, inquirer);
+        }
+        else if (!instanceHost.isResolved &&
+            instanceWrapper.forwardRef &&
+            (contextId !== constants_1.STATIC_CONTEXT || !!inquirerId)) {
+            /**
+             * When circular dependency has been detected between
+             * either request/transient providers, we have to asynchronously
+             * resolve instance host for a specific contextId or inquirer, to ensure
+             * that eventual lazily created instance will be merged with the prototype
+             * instantiated beforehand.
+             */
+            instanceHost.donePromise &&
+                instanceHost.donePromise.then(() => this.loadProvider(instanceWrapper, moduleRef, contextId, inquirer));
+        }
+        if (instanceWrapper.async) {
+            const host = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+            host.instance = await host.instance;
+            instanceWrapper.setInstanceByContextId(contextId, host, inquirerId);
+        }
+        return instanceWrapper;
+    }
+    async lookupComponent(providers, moduleRef, dependencyContext, wrapper, contextId = constants_1.STATIC_CONTEXT, inquirer, keyOrIndex) {
+        const token = wrapper.token || wrapper.name;
+        const { name } = dependencyContext;
+        if (wrapper && token === name) {
+            throw new unknown_dependencies_exception_1.UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef, { id: wrapper.id });
+        }
+        if (name && providers.has(name)) {
+            const instanceWrapper = providers.get(name);
+            this.printFoundInModuleLog(name, moduleRef);
+            this.addDependencyMetadata(keyOrIndex ?? "", wrapper, instanceWrapper);
+            return instanceWrapper;
+        }
+        return this.lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, contextId, inquirer, keyOrIndex);
+    }
+    async lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, contextId = constants_1.STATIC_CONTEXT, inquirer, keyOrIndex) {
+        const instanceWrapper = await this.lookupComponentInImports(moduleRef, dependencyContext.name, wrapper, [], contextId, inquirer, keyOrIndex);
+        if ((0, shared_helper_1.isNull)(instanceWrapper)) {
+            throw new unknown_dependencies_exception_1.UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef, { id: wrapper.id });
+        }
+        return instanceWrapper;
+    }
+    async lookupComponentInImports(moduleRef, name, wrapper, moduleRegistry = [], contextId = constants_1.STATIC_CONTEXT, inquirer, keyOrIndex, isTraversing) {
+        let instanceWrapperRef = null;
+        const imports = moduleRef.imports || new Set();
+        const identity = (item) => item;
+        let children = [...imports.values()].filter(identity);
+        if (isTraversing) {
+            const contextModuleExports = moduleRef.exports;
+            children = children.filter((child) => contextModuleExports.has(child.metatype));
+        }
+        for (const relatedModule of children) {
+            if (moduleRegistry.includes(relatedModule.id)) {
+                continue;
+            }
+            this.printLookingForProviderLog(name, relatedModule);
+            moduleRegistry.push(relatedModule.id);
+            const { providers, exports } = relatedModule;
+            if (!exports.has(name) || !providers.has(name)) {
+                const instanceRef = await this.lookupComponentInImports(relatedModule, name, wrapper, moduleRegistry, contextId, inquirer, keyOrIndex, true);
+                // Maybe Error
+                if (instanceRef && keyOrIndex) {
+                    this.addDependencyMetadata(keyOrIndex, wrapper, instanceRef);
+                    return instanceRef;
+                }
+                continue;
+            }
+            this.printFoundInModuleLog(name, relatedModule);
+            instanceWrapperRef = providers.get(name);
+            this.addDependencyMetadata(keyOrIndex ?? "", wrapper, instanceWrapperRef);
+            const inquirerId = this.getInquirerId(inquirer);
+            const instanceHost = instanceWrapperRef.getInstanceByContextId(this.getContextId(contextId, instanceWrapperRef), inquirerId);
+            if (!instanceHost.isResolved && !instanceWrapperRef.forwardRef) {
+                wrapper.settlementSignal?.insertRef(instanceWrapperRef.id);
+                await this.loadProvider(instanceWrapperRef, relatedModule, contextId, wrapper);
+                break;
+            }
+        }
+        return instanceWrapperRef;
+    }
+    async resolveProperties(wrapper, moduleRef, inject, contextId = constants_1.STATIC_CONTEXT, inquirer, parentInquirer) {
+        if (!(0, shared_helper_1.isNull)(inject)) {
+            return [];
+        }
+        const metadata = wrapper.getPropertiesMetadata();
+        if (metadata && contextId !== constants_1.STATIC_CONTEXT) {
+            return this.loadPropertiesMetadata(metadata, contextId, inquirer);
+        }
+        const properties = this.reflectProperties(wrapper.metatype);
+        const instances = await Promise.all(properties.map(async (item) => {
+            try {
+                const dependencyContext = {
+                    key: item.key,
+                    name: item.name,
+                };
+                if (this.isInquirer(item.name, parentInquirer)) {
+                    return parentInquirer && parentInquirer.instance;
+                }
+                const paramWrapper = await this.resolveSingleParam(wrapper, item.name, dependencyContext, moduleRef, contextId, inquirer, item.key);
+                if (!paramWrapper) {
+                    return undefined;
+                }
+                const inquirerId = this.getInquirerId(inquirer);
+                const instanceHost = paramWrapper.getInstanceByContextId(this.getContextId(contextId, paramWrapper), inquirerId);
+                return instanceHost.instance;
+            }
+            catch (err) {
+                if (!item.isOptional) {
+                    throw err;
+                }
+                return undefined;
+            }
+        }));
+        return properties.map((item, index) => ({
+            ...item,
+            instance: instances[index],
+        }));
+    }
+    reflectProperties(type) {
+        const properties = Reflect.getMetadata(constants_2.PROPERTY_DEPS_METADATA, type) || [];
+        const optionalKeys = Reflect.getMetadata(constants_2.OPTIONAL_PROPERTY_DEPS_METADATA, type) || [];
+        return properties.map((item) => ({
+            ...item,
+            name: item.type,
+            isOptional: optionalKeys.includes(item.key),
+        }));
+    }
+    applyProperties(instance, properties) {
+        if (!(0, shared_helper_1.isObject)(instance)) {
+            return undefined;
+        }
+        properties
+            .filter((item) => !(0, shared_helper_1.isNull)(item.instance))
+            .forEach((item) => {
+            // Maybe Error
+            // @ts-ignore
+            instance[item.key] = item.instance;
+        });
+    }
+    async instantiateClass(instances, wrapper, targetMetatype, contextId = constants_1.STATIC_CONTEXT, inquirer) {
+        const { metatype, inject } = wrapper;
+        const inquirerId = this.getInquirerId(inquirer);
+        const instanceHost = targetMetatype.getInstanceByContextId(this.getContextId(contextId, targetMetatype), inquirerId);
+        const isInContext = wrapper.isStatic(contextId, inquirer) ||
+            wrapper.isInRequestScope(contextId, inquirer) ||
+            wrapper.isLazyTransient(contextId, inquirer) ||
+            wrapper.isExplicitlyRequested(contextId, inquirer);
+        if (this.options?.preview && !wrapper.host?.initOnPreview) {
+            instanceHost.isResolved = true;
+            return instanceHost.instance;
+        }
+        if ((0, shared_helper_1.isNull)(inject) && isInContext) {
+            instanceHost.instance = wrapper.forwardRef
+                ? Object.assign(instanceHost.instance, new metatype(...instances))
+                : new metatype(...instances);
+        }
+        else if (isInContext) {
+            const factoryReturnValue = targetMetatype.metatype(...instances);
+            instanceHost.instance = await factoryReturnValue;
+        }
+        instanceHost.isResolved = true;
+        return instanceHost.instance;
+    }
+    async loadPerContext(instance, moduleRef, collection, ctx, wrapper) {
+        if (!wrapper) {
+            const injectionToken = instance.constructor;
+            wrapper = collection.get(injectionToken);
+        }
+        await this.loadInstance(wrapper, collection, moduleRef, ctx, wrapper);
+        await this.loadEnhancersPerContext(wrapper, ctx, wrapper);
+        const host = wrapper.getInstanceByContextId(this.getContextId(ctx, wrapper), wrapper.id);
+        return host && host.instance;
+    }
+    async loadEnhancersPerContext(wrapper, ctx, inquirer) {
+        const enhancers = wrapper.getEnhancersMetadata() || [];
+        const loadEnhancer = (item) => {
+            const hostModule = item.host;
+            return this.loadInstance(item, hostModule.injectables, hostModule, ctx, inquirer);
+        };
+        await Promise.all(enhancers.map(loadEnhancer));
+    }
+    async loadCtorMetadata(metadata, contextId, inquirer, parentInquirer) {
+        const hosts = await Promise.all(metadata.map(async (item) => this.resolveScopedComponentHost(item, contextId, inquirer, parentInquirer)));
+        const inquirerId = this.getInquirerId(inquirer);
+        return hosts.map((item) => item?.getInstanceByContextId(this.getContextId(contextId, item), inquirerId).instance);
+    }
+    async loadPropertiesMetadata(metadata, contextId, inquirer) {
+        const dependenciesHosts = await Promise.all(metadata.map(async ({ wrapper: item, key }) => ({
+            key,
+            host: await this.resolveComponentHost(item.host, item, contextId, inquirer),
+        })));
+        const inquirerId = this.getInquirerId(inquirer);
+        return dependenciesHosts.map(({ key, host }) => ({
+            key,
+            name: key,
+            instance: host.getInstanceByContextId(this.getContextId(contextId, host), inquirerId).instance,
+        }));
+    }
+    getInquirerId(inquirer) {
+        return inquirer && inquirer.id;
+    }
+    resolveScopedComponentHost(item, contextId, inquirer, parentInquirer) {
+        return this.isInquirerRequest(item, parentInquirer)
+            ? parentInquirer
+            : this.resolveComponentHost(item.host, item, contextId, inquirer);
+    }
+    isInquirerRequest(item, parentInquirer) {
+        return item.isTransient && item.name === constants_2.INQUIRER && parentInquirer;
+    }
+    isInquirer(param, parentInquirer) {
+        return param === constants_2.INQUIRER && parentInquirer;
+    }
+    addDependencyMetadata(keyOrIndex, hostWrapper, instanceWrapper) {
+        if ((0, shared_helper_1.isSymbol)(keyOrIndex) || (0, shared_helper_1.isString)(keyOrIndex)) {
+            hostWrapper.addPropertiesMetadata(keyOrIndex, instanceWrapper);
+        }
+        else {
+            hostWrapper.addCtorMetadata(keyOrIndex, instanceWrapper);
+        }
+    }
+    getTokenName(token) {
+        return (0, shared_helper_1.isFunction)(token) ? token.name : token.toString();
+    }
+    printResolvingDependenciesLog(token, inquirer) {
+        if (!this.isDebugMode()) {
+            return;
+        }
+        const tokenName = this.getTokenName(token);
+        const dependentName = (inquirer?.name && inquirer.name.toString?.()) ?? "unknown";
+        const isAlias = dependentName === tokenName;
+        const messageToPrint = `Resolving dependency ${color_helper_1.colors.cyanBright(tokenName)}${color_helper_1.colors.green(" in the ")}${color_helper_1.colors.yellow(dependentName)}${color_helper_1.colors.green(` provider ${isAlias ? "(alias)" : ""}`)}`;
+        this.logger.log(messageToPrint);
+    }
+    printLookingForProviderLog(token, moduleRef) {
+        if (!this.isDebugMode()) {
+            return;
+        }
+        const tokenName = this.getTokenName(token);
+        const moduleRefName = moduleRef?.metatype?.name ?? "unknown";
+        this.logger.log(`Looking for ${color_helper_1.colors.cyanBright(tokenName)}${color_helper_1.colors.green(" in ")}${color_helper_1.colors.magentaBright(moduleRefName)}`);
+    }
+    printFoundInModuleLog(token, moduleRef) {
+        if (!this.isDebugMode()) {
+            return;
+        }
+        const tokenName = this.getTokenName(token);
+        const moduleRefName = moduleRef?.metatype?.name ?? "unknown";
+        this.logger.log(`Found ${color_helper_1.colors.cyanBright(tokenName)}${color_helper_1.colors.green(" in ")}${color_helper_1.colors.magentaBright(moduleRefName)}`);
+    }
+    isDebugMode() {
+        return !!process.env.VENOK_DEBUG;
+    }
+    getContextId(contextId, instanceWrapper) {
+        return contextId.getParent
+            ? contextId.getParent({
+                token: instanceWrapper.token,
+                isTreeDurable: instanceWrapper.isDependencyTreeDurable(),
+            })
+            : contextId;
+    }
+    getNowTimestamp() {
+        return performance.now();
+    }
+}
+exports.Injector = Injector;

package/injector/instance/links-host.d.ts

@@ -0,0 +1,22 @@
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+import { InjectionToken } from "@venok/core/interfaces/modules";
+import { VenokContainer } from "@venok/core/injector/container";
+export interface InstanceLink<T = any> {
+    token: InjectionToken;
+    wrapperRef: InstanceWrapper<T>;
+    collection: Map<any, InstanceWrapper>;
+    moduleId: string;
+}
+export declare class InstanceLinksHost {
+    private readonly container;
+    private readonly instanceLinks;
+    constructor(container: VenokContainer);
+    get<T = any>(token: InjectionToken): InstanceLink<T>;
+    get<T = any>(token: InjectionToken, options?: {
+        moduleId?: string;
+        each?: boolean;
+    }): InstanceLink<T> | Array<InstanceLink<T>>;
+    private initialize;
+    private addLink;
+    private getInstanceNameByToken;
+}

package/injector/instance/links-host.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceLinksHost = void 0;
+const exceptions_1 = require("@venok/core/errors/exceptions");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+class InstanceLinksHost {
+    constructor(container) {
+        this.container = container;
+        this.instanceLinks = new Map();
+        this.initialize();
+    }
+    get(token, options = {}) {
+        const instanceLinksForGivenToken = this.instanceLinks.get(token);
+        if (!instanceLinksForGivenToken)
+            throw new exceptions_1.UnknownElementException(this.getInstanceNameByToken(token));
+        if (options.each)
+            return instanceLinksForGivenToken;
+        const instanceLink = options.moduleId
+            ? instanceLinksForGivenToken.find((item) => item.moduleId === options.moduleId)
+            : instanceLinksForGivenToken[instanceLinksForGivenToken.length - 1];
+        if (!instanceLink)
+            throw new exceptions_1.UnknownElementException(this.getInstanceNameByToken(token));
+        return instanceLink;
+    }
+    initialize() {
+        const modules = this.container.getModules();
+        modules.forEach((moduleRef) => {
+            const { providers, injectables } = moduleRef;
+            providers.forEach((wrapper, token) => this.addLink(wrapper, token, moduleRef, "providers"));
+            injectables.forEach((wrapper, token) => this.addLink(wrapper, token, moduleRef, "injectables"));
+        });
+    }
+    addLink(wrapper, token, moduleRef, collectionName) {
+        const instanceLink = {
+            moduleId: moduleRef.id,
+            wrapperRef: wrapper,
+            collection: moduleRef[collectionName],
+            token,
+        };
+        const existingLinks = this.instanceLinks.get(token);
+        if (!existingLinks)
+            this.instanceLinks.set(token, [instanceLink]);
+        else
+            existingLinks.push(instanceLink);
+    }
+    getInstanceNameByToken(token) {
+        return (0, shared_helper_1.isFunction)(token) ? token?.name : token;
+    }
+}
+exports.InstanceLinksHost = InstanceLinksHost;

package/injector/instance/loader.d.ts

@@ -0,0 +1,21 @@
+import { VenokContainer } from "@venok/core/injector/container";
+import { Injector } from "@venok/core/injector/injector";
+import { Logger, LoggerService } from "@venok/core/services/logger.service";
+import { Module } from "@venok/core/injector/module/module";
+import { GraphInspector } from "@venok/core/inspector/graph-inspector";
+export declare class InstanceLoader<TInjector extends Injector = Injector> {
+    protected readonly container: VenokContainer;
+    protected readonly injector: TInjector;
+    protected readonly graphInspector: GraphInspector;
+    private logger;
+    constructor(container: VenokContainer, injector: TInjector, graphInspector: GraphInspector, logger?: LoggerService);
+    setLogger(logger: Logger): void;
+    createInstancesOfDependencies(modules?: Map<string, Module>): Promise<void>;
+    private createPrototypes;
+    private createInstances;
+    private createPrototypesOfProviders;
+    private createInstancesOfProviders;
+    private createPrototypesOfInjectables;
+    private createInstancesOfInjectables;
+    private isModuleWhitelisted;
+}