@depup/nestjs__core 11.2.3-depup.0 → 12.0.2-depup.0

package/injector/injector.js

@@ -1,53 +1,50 @@
-"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 safe_instance_decorator_1 = require("../helpers/safe-instance-decorator");
-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, Scope, } 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 { makeSafeInstanceDecorator } from '../helpers/safe-instance-decorator.js';
+import { STATIC_CONTEXT } from './constants.js';
+import { isDebugMode } from './helpers/is-debug-mode.util.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 = (0, safe_instance_decorator_1.makeSafeInstanceDecorator)(options.instanceDecorator);
+            this.instanceDecorator = makeSafeInstanceDecorator(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, resolutionContext = { contextId: constants_2.STATIC_CONTEXT }) {
+    async loadInstance(wrapper, collection, moduleRef, resolutionContext = { contextId: STATIC_CONTEXT }) {
         const inquirerId = this.getContextInquirerId(resolutionContext);
         const instanceHost = wrapper.getInstanceByContextId(this.getContextId(resolutionContext.contextId, wrapper), inquirerId);
         if (instanceHost.isPending) {
             const settlementSignal = wrapper.settlementSignal;
             if (resolutionContext.inquirer &&
                 settlementSignal?.isCycle(resolutionContext.inquirer.id)) {
-                throw new exceptions_1.CircularDependencyException(`"${wrapper.name}"`);
+                throw new CircularDependencyException(`"${wrapper.name}"`);
             }
             return instanceHost.donePromise.then((err) => {
                 if (err) {
@@ -59,8 +56,8 @@ 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();
@@ -68,10 +65,11 @@ class Injector {
         try {
             const t0 = this.getNowTimestamp();
             const localResolutionContext = this.createResolutionContext(resolutionContext.contextId, wrapper, inquirerId);
-            const callback = async (instances) => {
+            const callback = async (instances, depth = 0) => {
                 const properties = await this.resolveProperties(wrapper, moduleRef, inject, localResolutionContext, resolutionContext.inquirer);
                 const instance = await this.instantiateClass(instances, wrapper, targetWrapper, wrapper.isTransient ? localResolutionContext : resolutionContext);
                 this.applyProperties(instance, properties);
+                wrapper.hierarchyLevel = depth + 1;
                 wrapper.initTime = this.getNowTimestamp() - t0;
                 settlementSignal.complete();
             };
@@ -86,25 +84,25 @@ 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, this.createResolutionContext(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, this.createResolutionContext(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, this.createResolutionContext(contextId, inquirer));
     }
-    async loadProvider(wrapper, moduleRef, resolutionContext = { contextId: constants_2.STATIC_CONTEXT }) {
+    async loadProvider(wrapper, moduleRef, resolutionContext = { contextId: STATIC_CONTEXT }) {
         if (this.shouldSkipProviderLoading(wrapper, resolutionContext)) {
             return;
         }
@@ -113,25 +111,26 @@ class Injector {
         await this.loadEnhancersPerContext(wrapper, resolutionContext.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, resolutionContext = { contextId: constants_2.STATIC_CONTEXT }, parentInquirer) {
+    async resolveConstructorParams(wrapper, moduleRef, inject, callback, resolutionContext = { contextId: STATIC_CONTEXT }, parentInquirer) {
         const metadata = wrapper.getCtorMetadata();
-        if (resolutionContext.contextId !== constants_2.STATIC_CONTEXT &&
+        if (resolutionContext.contextId !== STATIC_CONTEXT &&
             this.hasDenseCtorMetadata(wrapper, inject, metadata)) {
             const deps = await this.loadCtorMetadata(metadata, resolutionContext.contextId, resolutionContext.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)) {
@@ -157,6 +156,9 @@ class Injector {
                 await paramBarrier.signalAndWait();
                 const effectiveResolutionContext = this.getEffectiveResolutionContext(paramWrapper, resolutionContext, parentInquirer);
                 const paramWrapperWithInstance = await this.resolveComponentHost(moduleRef, paramWrapper, effectiveResolutionContext);
+                if (paramWrapperWithInstance.hierarchyLevel > depth) {
+                    depth = paramWrapperWithInstance.hierarchyLevel;
+                }
                 const instanceHost = paramWrapperWithInstance.getInstanceByContextId(this.getContextId(effectiveResolutionContext.contextId, paramWrapperWithInstance), effectiveResolutionContext.effectiveInquirerId);
                 if (!instanceHost.isResolved && !paramWrapperWithInstance.forwardRef) {
                     isResolved = false;
@@ -178,7 +180,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;
@@ -194,11 +196,24 @@ 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) &&
+            const token = value?.token;
+            if (isNil(token)) {
+                return false;
+            }
+            return (!isUndefined(value.optional) &&
                 !value.prototype);
         }
         const mapFactoryProviderInjectArray = (item, index) => {
+            const isWrappedDependency = !isNil(item) && typeof item === 'object' && 'token' in item;
+            const token = isWrappedDependency
+                ? item.token
+                : item;
+            if (isNil(token)) {
+                throw new UndefinedDependencyException(wrapper.name, {
+                    index,
+                    dependencies: (wrapper.inject ?? undefined),
+                });
+            }
             if (typeof item !== 'object') {
                 return item;
             }
@@ -217,22 +232,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 Array.from(paramtypes);
     }
     reflectOptionalParams(type) {
-        return Reflect.getMetadata(constants_1.OPTIONAL_DEPS_METADATA, type) || [];
+        return Reflect.getOwnMetadata(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, resolutionContext = { contextId: constants_2.STATIC_CONTEXT }, keyOrIndex) {
-        if ((0, shared_utils_1.isUndefined)(param)) {
+    async resolveSingleParam(wrapper, param, dependencyContext, moduleRef, resolutionContext = { contextId: STATIC_CONTEXT }, 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, resolutionContext, keyOrIndex);
@@ -244,13 +259,13 @@ class Injector {
         }
         return param;
     }
-    async resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, resolutionContext = { contextId: constants_2.STATIC_CONTEXT }, keyOrIndex) {
+    async resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, resolutionContext = { contextId: STATIC_CONTEXT }, keyOrIndex) {
         this.printResolvingDependenciesLog(token, resolutionContext.inquirer);
         this.printLookingForProviderLog(token, moduleRef);
         const providers = moduleRef.providers;
         return this.lookupComponent(providers, moduleRef, { ...dependencyContext, name: token }, wrapper, resolutionContext, keyOrIndex);
     }
-    async resolveComponentHost(moduleRef, instanceWrapper, resolutionContext = { contextId: constants_2.STATIC_CONTEXT }) {
+    async resolveComponentHost(moduleRef, instanceWrapper, resolutionContext = { contextId: STATIC_CONTEXT }) {
         const inquirerId = this.getContextInquirerId(resolutionContext);
         const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(resolutionContext.contextId, instanceWrapper), inquirerId);
         if (!instanceHost.isResolved && !instanceWrapper.forwardRef) {
@@ -259,7 +274,7 @@ class Injector {
         }
         else if (!instanceHost.isResolved &&
             instanceWrapper.forwardRef &&
-            (resolutionContext.contextId !== constants_2.STATIC_CONTEXT || !!inquirerId)) {
+            (resolutionContext.contextId !== STATIC_CONTEXT || !!inquirerId)) {
             /**
              * When circular dependency has been detected between
              * either request/transient providers, we have to asynchronously
@@ -269,7 +284,7 @@ class Injector {
              */
             if (instanceHost.donePromise) {
                 void instanceHost.donePromise
-                    .then(() => this.loadProvider(instanceWrapper, moduleRef, resolutionContext))
+                    .then(() => this.loadProvider(instanceWrapper, instanceWrapper.host ?? moduleRef, resolutionContext))
                     .catch(err => {
                     instanceWrapper.settlementSignal?.error(err);
                 });
@@ -292,11 +307,11 @@ class Injector {
         }
         return instanceWrapper;
     }
-    async lookupComponent(providers, moduleRef, dependencyContext, wrapper, resolutionContext = { contextId: constants_2.STATIC_CONTEXT }, keyOrIndex) {
+    async lookupComponent(providers, moduleRef, dependencyContext, wrapper, resolutionContext = { contextId: STATIC_CONTEXT }, 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);
@@ -306,14 +321,14 @@ class Injector {
         }
         return this.lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, resolutionContext, keyOrIndex);
     }
-    async lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, resolutionContext = { contextId: constants_2.STATIC_CONTEXT }, keyOrIndex) {
+    async lookupComponentInParentModules(dependencyContext, moduleRef, wrapper, resolutionContext = { contextId: STATIC_CONTEXT }, keyOrIndex) {
         const instanceWrapper = await this.lookupComponentInImports(moduleRef, dependencyContext.name, wrapper, new Set(), resolutionContext, 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(), resolutionContext = { contextId: constants_2.STATIC_CONTEXT }, keyOrIndex, isTraversing) {
+    async lookupComponentInImports(moduleRef, name, wrapper, moduleRegistry = new Set(), resolutionContext = { contextId: STATIC_CONTEXT }, keyOrIndex, isTraversing) {
         let instanceWrapperRef = null;
         const imports = moduleRef.imports || new Set();
         const identity = (item) => item;
@@ -349,16 +364,16 @@ class Injector {
         }
         return instanceWrapperRef;
     }
-    async resolveProperties(wrapper, moduleRef, inject, resolutionContext = { contextId: constants_2.STATIC_CONTEXT }, parentInquirer) {
-        if (!(0, shared_utils_1.isNil)(inject)) {
+    async resolveProperties(wrapper, moduleRef, inject, resolutionContext = { contextId: STATIC_CONTEXT }, parentInquirer) {
+        if (!isNil(inject)) {
             return [];
         }
         const metadata = wrapper.getPropertiesMetadata();
-        if (metadata && resolutionContext.contextId !== constants_2.STATIC_CONTEXT) {
+        if (metadata && resolutionContext.contextId !== STATIC_CONTEXT) {
             return this.loadPropertiesMetadata(metadata, resolutionContext.contextId, resolutionContext.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 = {
@@ -407,8 +422,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,
@@ -416,14 +431,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, resolutionContext = { contextId: constants_2.STATIC_CONTEXT }) {
+    async instantiateClass(instances, wrapper, targetMetatype, resolutionContext = { contextId: STATIC_CONTEXT }) {
         const { metatype, inject } = wrapper;
         const inquirerId = this.getContextInquirerId(resolutionContext);
         const instanceHost = targetMetatype.getInstanceByContextId(this.getContextId(resolutionContext.contextId, targetMetatype), inquirerId);
@@ -432,7 +447,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);
@@ -462,7 +477,7 @@ class Injector {
         return host && host.instance;
     }
     async loadEnhancersPerContext(wrapper, ctx, inquirer) {
-        if (ctx === constants_2.STATIC_CONTEXT) {
+        if (ctx === STATIC_CONTEXT) {
             return;
         }
         const enhancers = wrapper.getEnhancersMetadata() || [];
@@ -512,9 +527,9 @@ class Injector {
             wrapper.isExplicitlyRequested(resolutionContext.contextId, resolutionContext.inquirer));
     }
     shouldSkipProviderLoading(wrapper, resolutionContext) {
-        const isStaticContext = resolutionContext.contextId === constants_2.STATIC_CONTEXT;
+        const isStaticContext = resolutionContext.contextId === STATIC_CONTEXT;
         const hasNoInquirer = !resolutionContext.inquirer;
-        const isTopLevelStaticTransientOrRequestProvider = hasNoInquirer && (wrapper.isTransient || wrapper.scope === common_1.Scope.REQUEST);
+        const isTopLevelStaticTransientOrRequestProvider = hasNoInquirer && (wrapper.isTransient || wrapper.scope === Scope.REQUEST);
         const isStaticInquirerOutsideResolutionContext = !!resolutionContext.inquirer &&
             !this.isInContext(resolutionContext.inquirer, this.createResolutionContext(resolutionContext.contextId, resolutionContext.inquirer));
         const shouldSkipForStaticBootstrap = isStaticContext &&
@@ -532,7 +547,7 @@ class Injector {
     getEffectiveInquirer(dependency, resolutionContext, parentInquirer) {
         const { inquirer, contextId } = resolutionContext;
         if (dependency?.isTransient && inquirer?.isTransient && parentInquirer) {
-            if (contextId === constants_2.STATIC_CONTEXT) {
+            if (contextId === STATIC_CONTEXT) {
                 return inquirer.getRootInquirer() ?? parentInquirer;
             }
             return parentInquirer;
@@ -541,7 +556,7 @@ class Injector {
     }
     getEffectiveInquirerId(dependency, resolutionContext, parentInquirer) {
         const { contextId, inquirer, effectiveInquirerId } = resolutionContext;
-        if (contextId === constants_2.STATIC_CONTEXT &&
+        if (contextId === STATIC_CONTEXT &&
             dependency?.isTransient &&
             inquirer?.isTransient &&
             parentInquirer) {
@@ -553,7 +568,7 @@ class Injector {
     }
     getStaticTransientResolutionContext(resolutionContext, parentInquirer) {
         const { contextId, inquirer, effectiveInquirerId } = resolutionContext;
-        if (contextId === constants_2.STATIC_CONTEXT &&
+        if (contextId === STATIC_CONTEXT &&
             inquirer?.isTransient &&
             parentInquirer) {
             const baseInquirerId = effectiveInquirerId ?? this.getInquirerId(parentInquirer);
@@ -571,7 +586,7 @@ class Injector {
         // The fast path requires a fully populated metadata array.
         // While another request is still registering dependency metadata,
         // sparse entries here would feed request-scoped factories `undefined`.
-        const expectedDepsLength = !(0, shared_utils_1.isNil)(inject)
+        const expectedDepsLength = !isNil(inject)
             ? inject.length
             : wrapper.metatype
                 ? this.reflectConstructorParams(wrapper.metatype).length
@@ -592,13 +607,13 @@ class Injector {
             : this.resolveComponentHost(item.host, item, this.getEffectiveResolutionContext(item, this.createResolutionContext(contextId, inquirer), parentInquirer));
     }
     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 {
@@ -606,36 +621,33 @@ 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()) {
+        if (!isDebugMode()) {
             return;
         }
         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) {
-        if (!this.isDebugMode()) {
+        if (!isDebugMode()) {
             return;
         }
         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()) {
+        if (!isDebugMode()) {
             return;
         }
         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)}`);
-    }
-    isDebugMode() {
-        return !!process.env.NEST_DEBUG;
+        this.logger.log(`Found ${clc.cyanBright(tokenName)}${clc.green(' in ')}${clc.magentaBright(moduleRefName)}`);
     }
     getContextId(contextId, instanceWrapper) {
         return contextId.getParent
@@ -646,7 +658,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;