@nestjs/core 11.1.16 → 12.0.0-alpha.0

package/injector/injector.js

@@ -1,51 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injector = void 0;
-const common_1 = require("@nestjs/common");
-const constants_1 = require("@nestjs/common/constants");
-const cli_colors_util_1 = require("@nestjs/common/utils/cli-colors.util");
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const iterare_1 = require("iterare");
-const perf_hooks_1 = require("perf_hooks");
-const exceptions_1 = require("../errors/exceptions");
-const runtime_exception_1 = require("../errors/exceptions/runtime.exception");
-const undefined_dependency_exception_1 = require("../errors/exceptions/undefined-dependency.exception");
-const unknown_dependencies_exception_1 = require("../errors/exceptions/unknown-dependencies.exception");
-const barrier_1 = require("../helpers/barrier");
-const constants_2 = require("./constants");
-const inquirer_1 = require("./inquirer");
-const instance_wrapper_1 = require("./instance-wrapper");
-const settlement_signal_1 = require("./settlement-signal");
-class Injector {
+import { Logger, } from '@nestjs/common';
+import { OPTIONAL_DEPS_METADATA, OPTIONAL_PROPERTY_DEPS_METADATA, PARAMTYPES_METADATA, PROPERTY_DEPS_METADATA, SELF_DECLARED_DEPS_METADATA, clc, isFunction, isNil, isObject, isString, isSymbol, isUndefined, } from '@nestjs/common/internal';
+import { iterate } from 'iterare';
+import { performance } from 'perf_hooks';
+import { CircularDependencyException } from '../errors/exceptions/index.js';
+import { RuntimeException } from '../errors/exceptions/runtime.exception.js';
+import { UndefinedDependencyException } from '../errors/exceptions/undefined-dependency.exception.js';
+import { UnknownDependenciesException } from '../errors/exceptions/unknown-dependencies.exception.js';
+import { Barrier } from '../helpers/barrier.js';
+import { STATIC_CONTEXT } from './constants.js';
+import { INQUIRER } from './inquirer/index.js';
+import { InstanceWrapper, } from './instance-wrapper.js';
+import { SettlementSignal } from './settlement-signal.js';
+export class Injector {
+    options;
+    logger = new Logger('InjectorLogger');
+    instanceDecorator = (target) => target;
     constructor(options) {
         this.options = options;
-        this.logger = new common_1.Logger('InjectorLogger');
-        this.instanceDecorator = (target) => target;
         if (options?.instanceDecorator) {
             this.instanceDecorator = options.instanceDecorator;
         }
     }
-    loadPrototype({ token }, collection, contextId = constants_2.STATIC_CONTEXT) {
+    loadPrototype({ token }, collection, contextId = STATIC_CONTEXT) {
         if (!collection) {
             return;
         }
         const target = collection.get(token);
         const instance = target.createPrototype(contextId);
         if (instance) {
-            const wrapper = new instance_wrapper_1.InstanceWrapper({
+            const wrapper = new InstanceWrapper({
                 ...target,
                 instance,
             });
             collection.set(token, wrapper);
         }
     }
-    async loadInstance(wrapper, collection, moduleRef, contextId = constants_2.STATIC_CONTEXT, inquirer) {
+    async loadInstance(wrapper, collection, moduleRef, contextId = STATIC_CONTEXT, inquirer) {
         const inquirerId = this.getInquirerId(inquirer);
         const instanceHost = wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId);
         if (instanceHost.isPending) {
             const settlementSignal = wrapper.settlementSignal;
             if (inquirer && settlementSignal?.isCycle(inquirer.id)) {
-                throw new exceptions_1.CircularDependencyException(`"${wrapper.name}"`);
+                throw new CircularDependencyException(`"${wrapper.name}"`);
             }
             return instanceHost.donePromise.then((err) => {
                 if (err) {
@@ -57,18 +53,19 @@ class Injector {
         const token = wrapper.token || wrapper.name;
         const { inject } = wrapper;
         const targetWrapper = collection.get(token);
-        if ((0, shared_utils_1.isUndefined)(targetWrapper)) {
-            throw new runtime_exception_1.RuntimeException();
+        if (isUndefined(targetWrapper)) {
+            throw new RuntimeException();
         }
         if (instanceHost.isResolved) {
             return settlementSignal.complete();
         }
         try {
             const t0 = this.getNowTimestamp();
-            const callback = async (instances) => {
+            const callback = async (instances, depth = 0) => {
                 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.hierarchyLevel = depth + 1;
                 wrapper.initTime = this.getNowTimestamp() - t0;
                 settlementSignal.complete();
             };
@@ -80,48 +77,49 @@ class Injector {
             throw err;
         }
     }
-    async loadMiddleware(wrapper, collection, moduleRef, contextId = constants_2.STATIC_CONTEXT, inquirer) {
+    async loadMiddleware(wrapper, collection, moduleRef, contextId = STATIC_CONTEXT, inquirer) {
         const { metatype, token } = wrapper;
         const targetWrapper = collection.get(token);
-        if (!(0, shared_utils_1.isUndefined)(targetWrapper.instance)) {
+        if (!isUndefined(targetWrapper.instance)) {
             return;
         }
         targetWrapper.instance = Object.create(metatype.prototype);
         await this.loadInstance(wrapper, collection, moduleRef, contextId, inquirer || wrapper);
     }
-    async loadController(wrapper, moduleRef, contextId = constants_2.STATIC_CONTEXT) {
+    async loadController(wrapper, moduleRef, contextId = STATIC_CONTEXT) {
         const controllers = moduleRef.controllers;
         await this.loadInstance(wrapper, controllers, moduleRef, contextId, wrapper);
         await this.loadEnhancersPerContext(wrapper, contextId, wrapper);
     }
-    async loadInjectable(wrapper, moduleRef, contextId = constants_2.STATIC_CONTEXT, inquirer) {
+    async loadInjectable(wrapper, moduleRef, contextId = STATIC_CONTEXT, inquirer) {
         const injectables = moduleRef.injectables;
         await this.loadInstance(wrapper, injectables, moduleRef, contextId, inquirer);
     }
-    async loadProvider(wrapper, moduleRef, contextId = constants_2.STATIC_CONTEXT, inquirer) {
+    async loadProvider(wrapper, moduleRef, contextId = 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();
+        const settlementSignal = new SettlementSignal();
         instancePerContext.donePromise = settlementSignal.asPromise();
         instancePerContext.isPending = true;
         host.settlementSignal = settlementSignal;
         return settlementSignal;
     }
-    async resolveConstructorParams(wrapper, moduleRef, inject, callback, contextId = constants_2.STATIC_CONTEXT, inquirer, parentInquirer) {
+    async resolveConstructorParams(wrapper, moduleRef, inject, callback, contextId = STATIC_CONTEXT, inquirer, parentInquirer) {
         const metadata = wrapper.getCtorMetadata();
-        if (metadata && contextId !== constants_2.STATIC_CONTEXT) {
+        if (metadata && contextId !== STATIC_CONTEXT) {
             const deps = await this.loadCtorMetadata(metadata, contextId, inquirer, parentInquirer);
             return callback(deps);
         }
-        const isFactoryProvider = !(0, shared_utils_1.isNil)(inject);
+        const isFactoryProvider = !isNil(inject);
         const [dependencies, optionalDependenciesIds] = isFactoryProvider
             ? this.getFactoryProviderDependencies(wrapper)
             : this.getClassDependencies(wrapper);
-        const paramBarrier = new barrier_1.Barrier(dependencies.length);
+        const paramBarrier = new Barrier(dependencies.length);
         let isResolved = true;
+        let depth = 0;
         const resolveParam = async (param, index) => {
             try {
                 if (this.isInquirer(param, parentInquirer)) {
@@ -146,6 +144,9 @@ class Injector {
                 await paramBarrier.signalAndWait();
                 const effectiveInquirer = this.getEffectiveInquirer(paramWrapper, inquirer, parentInquirer, contextId);
                 const paramWrapperWithInstance = await this.resolveComponentHost(moduleRef, paramWrapper, contextId, effectiveInquirer);
+                if (paramWrapperWithInstance.hierarchyLevel > depth) {
+                    depth = paramWrapperWithInstance.hierarchyLevel;
+                }
                 const instanceHost = paramWrapperWithInstance.getInstanceByContextId(this.getContextId(contextId, paramWrapperWithInstance), this.getInquirerId(effectiveInquirer));
                 if (!instanceHost.isResolved && !paramWrapperWithInstance.forwardRef) {
                     isResolved = false;
@@ -167,7 +168,7 @@ class Injector {
             }
         };
         const instances = await Promise.all(dependencies.map(resolveParam));
-        isResolved && (await callback(instances));
+        isResolved && (await callback(instances, depth));
     }
     getClassDependencies(wrapper) {
         const ctorRef = wrapper.metatype;
@@ -183,8 +184,8 @@ class Injector {
          * We are duplicating it here because that one is not supposed to be exported.
          */
         function isOptionalFactoryDependency(value) {
-            return (!(0, shared_utils_1.isUndefined)(value.token) &&
-                !(0, shared_utils_1.isUndefined)(value.optional) &&
+            return (!isUndefined(value.token) &&
+                !isUndefined(value.optional) &&
                 !value.prototype);
         }
         const mapFactoryProviderInjectArray = (item, index) => {
@@ -206,22 +207,22 @@ class Injector {
     }
     reflectConstructorParams(type) {
         const paramtypes = [
-            ...(Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, type) || []),
+            ...(Reflect.getMetadata(PARAMTYPES_METADATA, type) || []),
         ];
         const selfParams = this.reflectSelfParams(type);
         selfParams.forEach(({ index, param }) => (paramtypes[index] = param));
         return paramtypes;
     }
     reflectOptionalParams(type) {
-        return Reflect.getMetadata(constants_1.OPTIONAL_DEPS_METADATA, type) || [];
+        return Reflect.getMetadata(OPTIONAL_DEPS_METADATA, type) || [];
     }
     reflectSelfParams(type) {
-        return Reflect.getMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, type) || [];
+        return Reflect.getMetadata(SELF_DECLARED_DEPS_METADATA, type) || [];
     }
-    async resolveSingleParam(wrapper, param, dependencyContext, moduleRef, contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex) {
-        if ((0, shared_utils_1.isUndefined)(param)) {
+    async resolveSingleParam(wrapper, param, dependencyContext, moduleRef, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
+        if (isUndefined(param)) {
             this.logger.log('Nest 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);
+            throw new UndefinedDependencyException(wrapper.name, dependencyContext, moduleRef);
         }
         const token = this.resolveParamToken(wrapper, param);
         return this.resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, contextId, inquirer, keyOrIndex);
@@ -233,13 +234,13 @@ class Injector {
         }
         return param;
     }
-    async resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex) {
+    async resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
         this.printResolvingDependenciesLog(token, inquirer);
         this.printLookingForProviderLog(token, moduleRef);
         const providers = moduleRef.providers;
         return this.lookupComponent(providers, moduleRef, { ...dependencyContext, name: token }, wrapper, contextId, inquirer, keyOrIndex);
     }
-    async resolveComponentHost(moduleRef, instanceWrapper, contextId = constants_2.STATIC_CONTEXT, inquirer) {
+    async resolveComponentHost(moduleRef, instanceWrapper, contextId = STATIC_CONTEXT, inquirer) {
         const inquirerId = this.getInquirerId(inquirer);
         const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
         if (!instanceHost.isResolved && !instanceWrapper.forwardRef) {
@@ -248,7 +249,7 @@ class Injector {
         }
         else if (!instanceHost.isResolved &&
             instanceWrapper.forwardRef &&
-            (contextId !== constants_2.STATIC_CONTEXT || !!inquirerId)) {
+            (contextId !== STATIC_CONTEXT || !!inquirerId)) {
             /**
              * When circular dependency has been detected between
              * either request/transient providers, we have to asynchronously
@@ -270,11 +271,11 @@ class Injector {
         }
         return instanceWrapper;
     }
-    async lookupComponent(providers, moduleRef, dependencyContext, wrapper, contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex) {
+    async lookupComponent(providers, moduleRef, dependencyContext, wrapper, contextId = 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 });
+            throw new UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef, { id: wrapper.id });
         }
         if (name && providers.has(name)) {
             const instanceWrapper = providers.get(name);
@@ -284,14 +285,14 @@ class Injector {
         }
         return this.lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, contextId, inquirer, keyOrIndex);
     }
-    async lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex) {
+    async lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, contextId = STATIC_CONTEXT, inquirer, keyOrIndex) {
         const instanceWrapper = await this.lookupComponentInImports(moduleRef, dependencyContext.name, wrapper, new Set(), contextId, inquirer, keyOrIndex);
-        if ((0, shared_utils_1.isNil)(instanceWrapper)) {
-            throw new unknown_dependencies_exception_1.UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef, { id: wrapper.id });
+        if (isNil(instanceWrapper)) {
+            throw new UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef, { id: wrapper.id });
         }
         return instanceWrapper;
     }
-    async lookupComponentInImports(moduleRef, name, wrapper, moduleRegistry = new Set(), contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex, isTraversing) {
+    async lookupComponentInImports(moduleRef, name, wrapper, moduleRegistry = new Set(), contextId = STATIC_CONTEXT, inquirer, keyOrIndex, isTraversing) {
         let instanceWrapperRef = null;
         const imports = moduleRef.imports || new Set();
         const identity = (item) => item;
@@ -331,16 +332,16 @@ class Injector {
         }
         return instanceWrapperRef;
     }
-    async resolveProperties(wrapper, moduleRef, inject, contextId = constants_2.STATIC_CONTEXT, inquirer, parentInquirer) {
-        if (!(0, shared_utils_1.isNil)(inject)) {
+    async resolveProperties(wrapper, moduleRef, inject, contextId = STATIC_CONTEXT, inquirer, parentInquirer) {
+        if (!isNil(inject)) {
             return [];
         }
         const metadata = wrapper.getPropertiesMetadata();
-        if (metadata && contextId !== constants_2.STATIC_CONTEXT) {
+        if (metadata && contextId !== STATIC_CONTEXT) {
             return this.loadPropertiesMetadata(metadata, contextId, inquirer);
         }
         const properties = this.reflectProperties(wrapper.metatype);
-        const propertyBarrier = new barrier_1.Barrier(properties.length);
+        const propertyBarrier = new Barrier(properties.length);
         const instances = await Promise.all(properties.map(async (item) => {
             try {
                 const dependencyContext = {
@@ -388,8 +389,8 @@ class Injector {
         }));
     }
     reflectProperties(type) {
-        const properties = Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, type) || [];
-        const optionalKeys = Reflect.getMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, type) || [];
+        const properties = Reflect.getMetadata(PROPERTY_DEPS_METADATA, type) || [];
+        const optionalKeys = Reflect.getMetadata(OPTIONAL_PROPERTY_DEPS_METADATA, type) || [];
         return properties.map((item) => ({
             ...item,
             name: item.type,
@@ -397,14 +398,14 @@ class Injector {
         }));
     }
     applyProperties(instance, properties) {
-        if (!(0, shared_utils_1.isObject)(instance)) {
-            return undefined;
+        if (!isObject(instance)) {
+            return;
         }
-        (0, iterare_1.iterate)(properties)
-            .filter(item => !(0, shared_utils_1.isNil)(item.instance))
+        iterate(properties)
+            .filter(item => !isNil(item.instance))
             .forEach(item => (instance[item.key] = item.instance));
     }
-    async instantiateClass(instances, wrapper, targetMetatype, contextId = constants_2.STATIC_CONTEXT, inquirer) {
+    async instantiateClass(instances, wrapper, targetMetatype, contextId = STATIC_CONTEXT, inquirer) {
         const { metatype, inject } = wrapper;
         const inquirerId = this.getInquirerId(inquirer);
         const instanceHost = targetMetatype.getInstanceByContextId(this.getContextId(contextId, targetMetatype), inquirerId);
@@ -416,7 +417,7 @@ class Injector {
             instanceHost.isResolved = true;
             return instanceHost.instance;
         }
-        if ((0, shared_utils_1.isNil)(inject) && isInContext) {
+        if (isNil(inject) && isInContext) {
             instanceHost.instance = wrapper.forwardRef
                 ? Object.assign(instanceHost.instance, new metatype(...instances))
                 : new metatype(...instances);
@@ -484,7 +485,7 @@ class Injector {
         return dependency?.isTransient &&
             inquirer?.isTransient &&
             parentInquirer &&
-            contextId !== constants_2.STATIC_CONTEXT
+            contextId !== STATIC_CONTEXT
             ? parentInquirer
             : inquirer;
     }
@@ -494,13 +495,13 @@ class Injector {
             : this.resolveComponentHost(item.host, item, contextId, this.getEffectiveInquirer(item, inquirer, parentInquirer, contextId));
     }
     isInquirerRequest(item, parentInquirer) {
-        return item.isTransient && item.name === inquirer_1.INQUIRER && parentInquirer;
+        return item.isTransient && item.name === INQUIRER && parentInquirer;
     }
     isInquirer(param, parentInquirer) {
-        return param === inquirer_1.INQUIRER && parentInquirer;
+        return param === INQUIRER && parentInquirer;
     }
     addDependencyMetadata(keyOrIndex, hostWrapper, instanceWrapper) {
-        if ((0, shared_utils_1.isSymbol)(keyOrIndex) || (0, shared_utils_1.isString)(keyOrIndex)) {
+        if (isSymbol(keyOrIndex) || isString(keyOrIndex)) {
             hostWrapper.addPropertiesMetadata(keyOrIndex, instanceWrapper);
         }
         else {
@@ -508,7 +509,7 @@ class Injector {
         }
     }
     getTokenName(token) {
-        return (0, shared_utils_1.isFunction)(token) ? token.name : token.toString();
+        return isFunction(token) ? token.name : token.toString();
     }
     printResolvingDependenciesLog(token, inquirer) {
         if (!this.isDebugMode()) {
@@ -517,7 +518,7 @@ class Injector {
         const tokenName = this.getTokenName(token);
         const dependentName = (inquirer?.name && inquirer.name.toString?.()) ?? 'unknown';
         const isAlias = dependentName === tokenName;
-        const messageToPrint = `Resolving dependency ${cli_colors_util_1.clc.cyanBright(tokenName)}${cli_colors_util_1.clc.green(' in the ')}${cli_colors_util_1.clc.yellow(dependentName)}${cli_colors_util_1.clc.green(` provider ${isAlias ? '(alias)' : ''}`)}`;
+        const messageToPrint = `Resolving dependency ${clc.cyanBright(tokenName)}${clc.green(' in the ')}${clc.yellow(dependentName)}${clc.green(` provider ${isAlias ? '(alias)' : ''}`)}`;
         this.logger.log(messageToPrint);
     }
     printLookingForProviderLog(token, moduleRef) {
@@ -526,7 +527,7 @@ class Injector {
         }
         const tokenName = this.getTokenName(token);
         const moduleRefName = moduleRef?.metatype?.name ?? 'unknown';
-        this.logger.log(`Looking for ${cli_colors_util_1.clc.cyanBright(tokenName)}${cli_colors_util_1.clc.green(' in ')}${cli_colors_util_1.clc.magentaBright(moduleRefName)}`);
+        this.logger.log(`Looking for ${clc.cyanBright(tokenName)}${clc.green(' in ')}${clc.magentaBright(moduleRefName)}`);
     }
     printFoundInModuleLog(token, moduleRef) {
         if (!this.isDebugMode()) {
@@ -534,7 +535,7 @@ class Injector {
         }
         const tokenName = this.getTokenName(token);
         const moduleRefName = moduleRef?.metatype?.name ?? 'unknown';
-        this.logger.log(`Found ${cli_colors_util_1.clc.cyanBright(tokenName)}${cli_colors_util_1.clc.green(' in ')}${cli_colors_util_1.clc.magentaBright(moduleRefName)}`);
+        this.logger.log(`Found ${clc.cyanBright(tokenName)}${clc.green(' in ')}${clc.magentaBright(moduleRefName)}`);
     }
     isDebugMode() {
         return !!process.env.NEST_DEBUG;
@@ -548,7 +549,6 @@ class Injector {
             : contextId;
     }
     getNowTimestamp() {
-        return perf_hooks_1.performance.now();
+        return performance.now();
     }
 }
-exports.Injector = Injector;

package/injector/inquirer/index.d.ts

@@ -1 +1 @@
-export * from './inquirer-constants';
+export * from './inquirer-constants.js';

package/injector/inquirer/index.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./inquirer-constants"), exports);
+export * from './inquirer-constants.js';

package/injector/inquirer/inquirer-constants.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.INQUIRER = void 0;
-exports.INQUIRER = 'INQUIRER';
+export const INQUIRER = 'INQUIRER';

package/injector/inquirer/inquirer-providers.d.ts

@@ -1,2 +1,2 @@
-import { Provider } from '@nestjs/common';
+import { type Provider } from '@nestjs/common';
 export declare const inquirerProvider: Provider;

package/injector/inquirer/inquirer-providers.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inquirerProvider = void 0;
-const common_1 = require("@nestjs/common");
-const inquirer_constants_1 = require("./inquirer-constants");
+import { Scope } from '@nestjs/common';
+import { INQUIRER } from './inquirer-constants.js';
 const noop = () => { };
-exports.inquirerProvider = {
-    provide: inquirer_constants_1.INQUIRER,
-    scope: common_1.Scope.TRANSIENT,
+export const inquirerProvider = {
+    provide: INQUIRER,
+    scope: Scope.TRANSIENT,
     useFactory: noop,
 };

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

@@ -1,6 +1,6 @@
-import { InjectionToken } from '@nestjs/common';
-import { NestContainer } from './container';
-import { InstanceWrapper } from './instance-wrapper';
+import type { InjectionToken } from '@nestjs/common';
+import { NestContainer } from './container.js';
+import { InstanceWrapper } from './instance-wrapper.js';
 export interface InstanceLink<T = any> {
     token: InjectionToken;
     wrapperRef: InstanceWrapper<T>;

package/injector/instance-links-host.js

@@ -1,18 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InstanceLinksHost = void 0;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const unknown_element_exception_1 = require("../errors/exceptions/unknown-element.exception");
-class InstanceLinksHost {
+import { UnknownElementException } from '../errors/exceptions/unknown-element.exception.js';
+import { isFunction } from '@nestjs/common/internal';
+export class InstanceLinksHost {
+    container;
+    instanceLinks = new Map();
     constructor(container) {
         this.container = container;
-        this.instanceLinks = new Map();
         this.initialize();
     }
     get(token, options = {}) {
         const instanceLinksForGivenToken = this.instanceLinks.get(token);
         if (!instanceLinksForGivenToken) {
-            throw new unknown_element_exception_1.UnknownElementException(this.getInstanceNameByToken(token));
+            throw new UnknownElementException(this.getInstanceNameByToken(token));
         }
         if (options.each) {
             return instanceLinksForGivenToken;
@@ -21,7 +19,7 @@ class InstanceLinksHost {
             ? instanceLinksForGivenToken.find(item => item.moduleId === options.moduleId)
             : instanceLinksForGivenToken[instanceLinksForGivenToken.length - 1];
         if (!instanceLink) {
-            throw new unknown_element_exception_1.UnknownElementException(this.getInstanceNameByToken(token));
+            throw new UnknownElementException(this.getInstanceNameByToken(token));
         }
         return instanceLink;
     }
@@ -50,7 +48,6 @@ class InstanceLinksHost {
         }
     }
     getInstanceNameByToken(token) {
-        return (0, shared_utils_1.isFunction)(token) ? token?.name : token;
+        return isFunction(token) ? token?.name : token;
     }
 }
-exports.InstanceLinksHost = InstanceLinksHost;

package/injector/instance-loader.d.ts

@@ -1,8 +1,8 @@
-import { Logger, LoggerService } from '@nestjs/common';
-import { GraphInspector } from '../inspector/graph-inspector';
-import { NestContainer } from './container';
-import { Injector } from './injector';
-import { Module } from './module';
+import { Logger, type LoggerService } from '@nestjs/common';
+import { GraphInspector } from '../inspector/graph-inspector.js';
+import { NestContainer } from './container.js';
+import { Injector } from './injector.js';
+import { Module } from './module.js';
 export declare class InstanceLoader<TInjector extends Injector = Injector> {
     protected readonly container: NestContainer;
     protected readonly injector: TInjector;

package/injector/instance-loader.js

@@ -1,11 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InstanceLoader = void 0;
-const common_1 = require("@nestjs/common");
-const messages_1 = require("../helpers/messages");
-const internal_core_module_1 = require("./internal-core-module/internal-core-module");
-class InstanceLoader {
-    constructor(container, injector, graphInspector, logger = new common_1.Logger(InstanceLoader.name, {
+import { Logger } from '@nestjs/common';
+import { MODULE_INIT_MESSAGE } from '../helpers/messages.js';
+import { InternalCoreModule } from './internal-core-module/internal-core-module.js';
+export class InstanceLoader {
+    container;
+    injector;
+    graphInspector;
+    logger;
+    constructor(container, injector, graphInspector, logger = new Logger(InstanceLoader.name, {
         timestamp: true,
     })) {
         this.container = container;
@@ -42,7 +43,7 @@ class InstanceLoader {
             await this.createInstancesOfControllers(moduleRef);
             const { name } = moduleRef;
             this.isModuleWhitelisted(name) &&
-                this.logger.log((0, messages_1.MODULE_INIT_MESSAGE) `${name}`);
+                this.logger.log(MODULE_INIT_MESSAGE `${name}`);
         }));
     }
     createPrototypesOfProviders(moduleRef) {
@@ -82,7 +83,6 @@ class InstanceLoader {
         }));
     }
     isModuleWhitelisted(name) {
-        return name !== internal_core_module_1.InternalCoreModule.name;
+        return name !== InternalCoreModule.name;
     }
 }
-exports.InstanceLoader = InstanceLoader;

package/injector/instance-wrapper.d.ts

@@ -1,8 +1,8 @@
-import { Provider, Scope, Type } from '@nestjs/common';
-import { EnhancerSubtype } from '@nestjs/common/constants';
-import { FactoryProvider, InjectionToken } from '@nestjs/common/interfaces';
-import { Module } from './module';
-import { SettlementSignal } from './settlement-signal';
+import type { FactoryProvider, InjectionToken } from '@nestjs/common';
+import { type Provider, Scope, type Type } from '@nestjs/common';
+import { type EnhancerSubtype } from '@nestjs/common/internal';
+import { Module } from './module.js';
+import { SettlementSignal } from './settlement-signal.js';
 export declare const INSTANCE_METADATA_SYMBOL: unique symbol;
 export declare const INSTANCE_ID_SYMBOL: unique symbol;
 export interface HostComponentInfo {
@@ -52,6 +52,9 @@ export declare class InstanceWrapper<T = any> {
     private transientMap?;
     private isTreeStatic;
     private isTreeDurable;
+    private _hierarchyLevel;
+    get hierarchyLevel(): number;
+    set hierarchyLevel(level: number);
     /**
      * The root inquirer reference. Present only if child instance wrapper
      * is transient and has a parent inquirer.