@nestjs/core 9.4.2 → 10.0.0

package/adapters/http-adapter.d.ts

@@ -25,6 +25,8 @@ export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any,
     patch(path: any, handler: RequestHandler): any;
     all(handler: RequestHandler): any;
     all(path: any, handler: RequestHandler): any;
+    search(port: string | number, callback?: () => void): any;
+    search(port: string | number, hostname: string, callback?: () => void): any;
     options(handler: RequestHandler): any;
     options(path: any, handler: RequestHandler): any;
     listen(port: string | number, callback?: () => void): any;

package/adapters/http-adapter.js

@@ -34,6 +34,9 @@ class AbstractHttpAdapter {
     all(...args) {
         return this.instance.all(...args);
     }
+    search(port, hostname, callback) {
+        return this.instance.search(port, hostname, callback);
+    }
     options(...args) {
         return this.instance.options(...args);
     }

package/discovery/discovery-module.js

@@ -8,12 +8,11 @@ const discovery_service_1 = require("./discovery-service");
 /**
  * @publicApi
  */
-let DiscoveryModule = class DiscoveryModule {
+let DiscoveryModule = exports.DiscoveryModule = class DiscoveryModule {
 };
-DiscoveryModule = tslib_1.__decorate([
+exports.DiscoveryModule = DiscoveryModule = tslib_1.__decorate([
     (0, common_1.Module)({
         providers: [metadata_scanner_1.MetadataScanner, discovery_service_1.DiscoveryService],
         exports: [metadata_scanner_1.MetadataScanner, discovery_service_1.DiscoveryService],
     })
 ], DiscoveryModule);
-exports.DiscoveryModule = DiscoveryModule;

package/discovery/discovery-service.js

@@ -7,7 +7,7 @@ const modules_container_1 = require("../injector/modules-container");
 /**
  * @publicApi
  */
-let DiscoveryService = class DiscoveryService {
+let DiscoveryService = exports.DiscoveryService = class DiscoveryService {
     constructor(modulesContainer) {
         this.modulesContainer = modulesContainer;
     }
@@ -32,8 +32,7 @@ let DiscoveryService = class DiscoveryService {
         return moduleRefs.filter(({ metatype }) => include.some(item => item === metatype));
     }
 };
-DiscoveryService = tslib_1.__decorate([
+exports.DiscoveryService = DiscoveryService = tslib_1.__decorate([
     (0, common_1.Injectable)(),
     tslib_1.__metadata("design:paramtypes", [modules_container_1.ModulesContainer])
 ], DiscoveryService);
-exports.DiscoveryService = DiscoveryService;

package/errors/exception-handler.js

@@ -12,5 +12,5 @@ class ExceptionHandler {
         ExceptionHandler.logger.error(exception.what(), exception.stack);
     }
 }
-ExceptionHandler.logger = new logger_service_1.Logger(ExceptionHandler.name);
 exports.ExceptionHandler = ExceptionHandler;
+ExceptionHandler.logger = new logger_service_1.Logger(ExceptionHandler.name);

package/errors/exceptions-zone.js

@@ -30,5 +30,5 @@ class ExceptionsZone {
         }
     }
 }
-ExceptionsZone.exceptionHandler = new exception_handler_1.ExceptionHandler();
 exports.ExceptionsZone = ExceptionsZone;
+ExceptionsZone.exceptionHandler = new exception_handler_1.ExceptionHandler();

package/errors/messages.js

@@ -7,14 +7,13 @@ const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
  * @param instance The instance which should get the name from
  */
 const getInstanceName = (instance) => {
-    var _a, _b;
-    if (instance === null || instance === void 0 ? void 0 : instance.forwardRef) {
-        return (_a = instance.forwardRef()) === null || _a === void 0 ? void 0 : _a.name;
+    if (instance?.forwardRef) {
+        return instance.forwardRef()?.name;
     }
-    if (instance === null || instance === void 0 ? void 0 : instance.module) {
-        return (_b = instance.module) === null || _b === void 0 ? void 0 : _b.name;
+    if (instance?.module) {
+        return instance.module?.name;
     }
-    return instance === null || instance === void 0 ? void 0 : instance.name;
+    return instance?.name;
 };
 /**
  * Returns the name of the dependency
@@ -85,7 +84,7 @@ Scope [${stringifyScope(scope)}]
 `;
 exports.UNDEFINED_FORWARDREF_MESSAGE = UNDEFINED_FORWARDREF_MESSAGE;
 const INVALID_MODULE_MESSAGE = (parentModule, index, scope) => {
-    const parentModuleName = (parentModule === null || parentModule === void 0 ? void 0 : parentModule.name) || 'module';
+    const parentModuleName = parentModule?.name || 'module';
     return `Nest cannot create the ${parentModuleName} instance.
 Received an unexpected value at index [${index}] of the ${parentModuleName} "imports" array.
 
@@ -102,7 +101,7 @@ Scope [${stringifyScope(scope)}]
 };
 exports.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = USING_INVALID_CLASS_AS_A_MODULE_MESSAGE;
 const UNDEFINED_MODULE_MESSAGE = (parentModule, index, scope) => {
-    const parentModuleName = (parentModule === null || parentModule === void 0 ? void 0 : parentModule.name) || 'module';
+    const parentModuleName = parentModule?.name || 'module';
     return `Nest cannot create the ${parentModuleName} instance.
 The module at index [${index}] of the ${parentModuleName} "imports" array is undefined.
 

package/exceptions/base-exception-filter.js

@@ -61,13 +61,13 @@ class BaseExceptionFilter {
      * @param err error object
      */
     isHttpError(err) {
-        return (err === null || err === void 0 ? void 0 : err.statusCode) && (err === null || err === void 0 ? void 0 : err.message);
+        return err?.statusCode && err?.message;
     }
 }
+exports.BaseExceptionFilter = BaseExceptionFilter;
 BaseExceptionFilter.logger = new common_1.Logger('ExceptionsHandler');
 tslib_1.__decorate([
     (0, common_1.Optional)(),
     (0, common_1.Inject)(),
     tslib_1.__metadata("design:type", http_adapter_host_1.HttpAdapterHost)
 ], BaseExceptionFilter.prototype, "httpAdapterHost", void 0);
-exports.BaseExceptionFilter = BaseExceptionFilter;

package/exceptions/exceptions-handler.d.ts

@@ -1,6 +1,6 @@
 import { HttpException } from '@nestjs/common';
-import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions/exception-filter-metadata.interface';
 import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
+import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions/exception-filter-metadata.interface';
 import { BaseExceptionFilter } from './base-exception-filter';
 export declare class ExceptionsHandler extends BaseExceptionFilter {
     private filters;

package/exceptions/exceptions-handler.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExceptionsHandler = void 0;
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
+const select_exception_filter_metadata_util_1 = require("@nestjs/common/utils/select-exception-filter-metadata.util");
 const base_exception_filter_1 = require("./base-exception-filter");
+const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
 class ExceptionsHandler extends base_exception_filter_1.BaseExceptionFilter {
     constructor() {
         super(...arguments);
@@ -25,11 +26,7 @@ class ExceptionsHandler extends base_exception_filter_1.BaseExceptionFilter {
         if ((0, shared_utils_1.isEmpty)(this.filters)) {
             return false;
         }
-        const isInstanceOf = (metatype) => exception instanceof metatype;
-        const filter = this.filters.find(({ exceptionMetatypes }) => {
-            const typeExists = !exceptionMetatypes.length || exceptionMetatypes.some(isInstanceOf);
-            return typeExists;
-        });
+        const filter = (0, select_exception_filter_metadata_util_1.selectExceptionFilterMetadata)(this.filters, exception);
         filter && filter.func(exception, ctx);
         return !!filter;
     }

package/exceptions/external-exception-filter.js

@@ -10,5 +10,5 @@ class ExternalExceptionFilter {
         throw exception;
     }
 }
-ExternalExceptionFilter.logger = new common_1.Logger('ExceptionsHandler');
 exports.ExternalExceptionFilter = ExternalExceptionFilter;
+ExternalExceptionFilter.logger = new common_1.Logger('ExceptionsHandler');

package/exceptions/external-exceptions-handler.d.ts

@@ -1,5 +1,5 @@
-import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions';
 import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
+import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions';
 import { ExternalExceptionFilter } from './external-exception-filter';
 export declare class ExternalExceptionsHandler extends ExternalExceptionFilter {
     private filters;

package/exceptions/external-exceptions-handler.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExternalExceptionsHandler = void 0;
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
+const select_exception_filter_metadata_util_1 = require("@nestjs/common/utils/select-exception-filter-metadata.util");
 const external_exception_filter_1 = require("./external-exception-filter");
+const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
 class ExternalExceptionsHandler extends external_exception_filter_1.ExternalExceptionFilter {
     constructor() {
         super(...arguments);
@@ -26,11 +27,7 @@ class ExternalExceptionsHandler extends external_exception_filter_1.ExternalExce
         if ((0, shared_utils_1.isEmpty)(this.filters)) {
             return null;
         }
-        const isInstanceOf = (metatype) => exception instanceof metatype;
-        const filter = this.filters.find(({ exceptionMetatypes }) => {
-            const typeExists = !exceptionMetatypes.length || exceptionMetatypes.some(isInstanceOf);
-            return typeExists;
-        });
+        const filter = (0, select_exception_filter_metadata_util_1.selectExceptionFilterMetadata)(this.filters, exception);
         return filter ? filter.func(exception, host) : null;
     }
 }

package/helpers/context-id-factory.js

@@ -27,7 +27,6 @@ class ContextIdFactory {
      * @param request request object
      */
     static getByRequest(request, propsToInspect = ['raw']) {
-        var _a;
         if (!request) {
             return ContextIdFactory.create();
         }
@@ -35,7 +34,7 @@ class ContextIdFactory {
             return request[request_constants_1.REQUEST_CONTEXT_ID];
         }
         for (const key of propsToInspect) {
-            if ((_a = request[key]) === null || _a === void 0 ? void 0 : _a[request_constants_1.REQUEST_CONTEXT_ID]) {
+            if (request[key]?.[request_constants_1.REQUEST_CONTEXT_ID]) {
                 return request[key][request_constants_1.REQUEST_CONTEXT_ID];
             }
         }

package/helpers/context-utils.js

@@ -33,7 +33,10 @@ class ContextUtils {
         if (!paramtypes) {
             return paramsProperties;
         }
-        return paramsProperties.map(param => (Object.assign(Object.assign({}, param), { metatype: paramtypes[param.index] })));
+        return paramsProperties.map(param => ({
+            ...param,
+            metatype: paramtypes[param.index],
+        }));
     }
     getCustomFactory(factory, data, contextFactory) {
         return (0, shared_utils_1.isFunction)(factory)

package/helpers/execution-context-host.js

@@ -43,6 +43,7 @@ class ExecutionContextHost {
         return Object.assign(this, {
             getClient: () => this.getArgByIndex(0),
             getData: () => this.getArgByIndex(1),
+            getPattern: () => this.getArgByIndex(this.getArgs().length - 1),
         });
     }
 }

package/injector/abstract-instance-resolver.js

@@ -19,7 +19,7 @@ class AbstractInstanceResolver {
         return pluckInstance(instanceLinkOrArray);
     }
     async resolvePerContext(typeOrToken, contextModule, contextId, options) {
-        const instanceLinkOrArray = (options === null || options === void 0 ? void 0 : options.strict)
+        const instanceLinkOrArray = options?.strict
             ? this.instanceLinksHost.get(typeOrToken, {
                 moduleId: contextModule.id,
                 each: options.each,

package/injector/compiler.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleCompiler = void 0;
-const tslib_1 = require("tslib");
 const module_token_factory_1 = require("./module-token-factory");
 class ModuleCompiler {
     constructor(moduleTokenFactory = new module_token_factory_1.ModuleTokenFactory()) {
@@ -15,12 +14,12 @@ class ModuleCompiler {
     extractMetadata(metatype) {
         if (!this.isDynamicModule(metatype)) {
             return {
-                type: (metatype === null || metatype === void 0 ? void 0 : metatype.forwardRef)
+                type: metatype?.forwardRef
                     ? metatype.forwardRef()
                     : metatype,
             };
         }
-        const { module: type } = metatype, dynamicMetadata = tslib_1.__rest(metatype, ["module"]);
+        const { module: type, ...dynamicMetadata } = metatype;
         return { type, dynamicMetadata };
     }
     isDynamicModule(module) {

package/injector/container.d.ts

@@ -8,6 +8,8 @@ import { ContextId } from './instance-wrapper';
 import { Module } from './module';
 import { ModuleTokenFactory } from './module-token-factory';
 import { ModulesContainer } from './modules-container';
+type ModuleMetatype = Type<any> | DynamicModule | Promise<DynamicModule>;
+type ModuleScope = Type<any>[];
 export declare class NestContainer {
     private readonly _applicationConfig;
     private readonly globalModules;
@@ -24,7 +26,9 @@ export declare class NestContainer {
     setHttpAdapter(httpAdapter: any): void;
     getHttpAdapterRef(): import("..").AbstractHttpAdapter<any, any, any>;
     getHttpAdapterHostRef(): import("..").HttpAdapterHost<import("..").AbstractHttpAdapter<any, any, any>>;
-    addModule(metatype: Type<any> | DynamicModule | Promise<DynamicModule>, scope: Type<any>[]): Promise<Module | undefined>;
+    addModule(metatype: ModuleMetatype, scope: ModuleScope): Promise<Module | undefined>;
+    replaceModule(metatypeToReplace: ModuleMetatype, newMetatype: ModuleMetatype, scope: ModuleScope): Promise<Module | undefined>;
+    private setModule;
     addDynamicMetadata(token: string, dynamicModuleMetadata: Partial<DynamicModule>, scope: Type<any>[]): Promise<void>;
     addDynamicModules(modules: any[], scope: Type<any>[]): Promise<void>;
     isGlobalModule(metatype: Type<any>, dynamicMetadata?: Partial<DynamicModule>): boolean;
@@ -52,3 +56,4 @@ export declare class NestContainer {
     registerRequestProvider<T = any>(request: T, contextId: ContextId): void;
     private shouldInitOnPreview;
 }
+export {};

package/injector/container.js

@@ -53,6 +53,27 @@ class NestContainer {
         if (this.modules.has(token)) {
             return this.modules.get(token);
         }
+        return this.setModule({
+            token,
+            type,
+            dynamicMetadata,
+        }, scope);
+    }
+    async replaceModule(metatypeToReplace, newMetatype, scope) {
+        // In DependenciesScanner#scanForModules we already check for undefined or invalid modules
+        // We still need to catch the edge-case of `forwardRef(() => undefined)`
+        if (!metatypeToReplace || !newMetatype) {
+            throw new exceptions_1.UndefinedForwardRefException(scope);
+        }
+        const { token } = await this.moduleCompiler.compile(metatypeToReplace);
+        const { type, dynamicMetadata } = await this.moduleCompiler.compile(newMetatype);
+        return this.setModule({
+            token,
+            type,
+            dynamicMetadata,
+        }, scope);
+    }
+    async setModule({ token, dynamicMetadata, type }, scope) {
         const moduleRef = new module_1.Module(type, this);
         moduleRef.token = token;
         moduleRef.initOnPreview = this.shouldInitOnPreview(type);
@@ -112,7 +133,7 @@ class NestContainer {
     addProvider(provider, token, enhancerSubtype) {
         const moduleRef = this.modules.get(token);
         if (!provider) {
-            throw new exceptions_1.CircularDependencyException(moduleRef === null || moduleRef === void 0 ? void 0 : moduleRef.metatype.name);
+            throw new exceptions_1.CircularDependencyException(moduleRef?.metatype.name);
         }
         if (!moduleRef) {
             throw new exceptions_1.UnknownModuleException();
@@ -159,9 +180,8 @@ class NestContainer {
         target.addRelatedModule(globalModule);
     }
     getDynamicMetadataByToken(token, metadataKey) {
-        var _a;
         const metadata = this.dynamicModulesMetadata.get(token);
-        return metadataKey ? (_a = metadata === null || metadata === void 0 ? void 0 : metadata[metadataKey]) !== null && _a !== void 0 ? _a : [] : metadata;
+        return metadataKey ? metadata?.[metadataKey] ?? [] : metadata;
     }
     registerCoreModuleRef(moduleRef) {
         this.internalCoreModule = moduleRef;

package/injector/helpers/provider-classifier.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isFactoryProvider = exports.isValueProvider = exports.isClassProvider = void 0;
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 function isClassProvider(provider) {
-    return Boolean(provider === null || provider === void 0 ? void 0 : provider.useClass);
+    return Boolean(provider?.useClass);
 }
 exports.isClassProvider = isClassProvider;
 function isValueProvider(provider) {
-    const providerValue = provider === null || provider === void 0 ? void 0 : provider.useValue;
+    const providerValue = provider?.useValue;
     return !(0, shared_utils_1.isUndefined)(providerValue);
 }
 exports.isValueProvider = isValueProvider;

package/injector/helpers/transient-instances.d.ts

@@ -1,12 +1,12 @@
+import { InjectionToken } from '@nestjs/common';
 import { InstanceWrapper } from '../instance-wrapper';
-import { InstanceToken } from '../module';
 /**
  * Returns the instances which are transient
  * @param instances The instances which should be checked whether they are transient
  */
-export declare function getTransientInstances(instances: [InstanceToken, InstanceWrapper][]): InstanceWrapper[];
+export declare function getTransientInstances(instances: [InjectionToken, InstanceWrapper][]): InstanceWrapper[];
 /**
  * Returns the instances which are not transient
  * @param instances The instances which should be checked whether they are transient
  */
-export declare function getNonTransientInstances(instances: [InstanceToken, InstanceWrapper][]): InstanceWrapper[];
+export declare function getNonTransientInstances(instances: [InjectionToken, InstanceWrapper][]): InstanceWrapper[];

package/injector/injector.d.ts

@@ -1,7 +1,7 @@
 import { InjectionToken } from '@nestjs/common';
 import { Controller, Injectable, Type } from '@nestjs/common/interfaces';
 import { ContextId, InstancePerContext, InstanceWrapper, PropertyMetadata } from './instance-wrapper';
-import { InstanceToken, Module } from './module';
+import { Module } from './module';
 /**
  * The type of an injectable dependency
  */
@@ -44,9 +44,9 @@ export declare class Injector {
     constructor(options?: {
         preview: boolean;
     });
-    loadPrototype<T>({ token }: InstanceWrapper<T>, collection: Map<InstanceToken, InstanceWrapper<T>>, contextId?: ContextId): void;
-    loadInstance<T>(wrapper: InstanceWrapper<T>, collection: Map<InstanceToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
-    loadMiddleware(wrapper: InstanceWrapper, collection: Map<InstanceToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    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>;
+    loadMiddleware(wrapper: InstanceWrapper, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
     loadController(wrapper: InstanceWrapper<Controller>, moduleRef: Module, contextId?: ContextId): 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>;
@@ -59,16 +59,16 @@ export declare class Injector {
     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: InstanceToken, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper>;
+    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: InstanceToken, wrapper: InstanceWrapper, moduleRegistry?: any[], contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number, isTraversing?: boolean): 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<InstanceToken, InstanceWrapper>, ctx: ContextId, wrapper?: 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[]>;

package/injector/injector.js

@@ -25,7 +25,10 @@ class Injector {
         const target = collection.get(token);
         const instance = target.createPrototype(contextId);
         if (instance) {
-            const wrapper = new instance_wrapper_1.InstanceWrapper(Object.assign(Object.assign({}, target), { instance }));
+            const wrapper = new instance_wrapper_1.InstanceWrapper({
+                ...target,
+                instance,
+            });
             collection.set(token, wrapper);
         }
     }
@@ -113,7 +116,7 @@ class Injector {
                 if (this.isInquirer(param, parentInquirer)) {
                     return parentInquirer && parentInquirer.instance;
                 }
-                if ((inquirer === null || inquirer === void 0 ? void 0 : inquirer.isTransient) && parentInquirer) {
+                if (inquirer?.isTransient && parentInquirer) {
                     inquirer = parentInquirer;
                     inquirerId = this.getInquirerId(parentInquirer);
                 }
@@ -122,7 +125,7 @@ class Injector {
                 if (!instanceHost.isResolved && !paramWrapper.forwardRef) {
                     isResolved = false;
                 }
-                return instanceHost === null || instanceHost === void 0 ? void 0 : instanceHost.instance;
+                return instanceHost?.instance;
             }
             catch (err) {
                 const isOptional = optionalDependenciesIds.includes(index);
@@ -143,7 +146,6 @@ class Injector {
         ];
     }
     getFactoryProviderDependencies(wrapper) {
-        var _a, _b;
         const optionalDependenciesIds = [];
         const isOptionalFactoryDep = (item) => !(0, shared_utils_1.isUndefined)(item.token) &&
             !(0, shared_utils_1.isUndefined)(item.optional);
@@ -155,12 +157,12 @@ class Injector {
                 if (item.optional) {
                     optionalDependenciesIds.push(index);
                 }
-                return item === null || item === void 0 ? void 0 : item.token;
+                return item?.token;
             }
             return item;
         };
         return [
-            (_b = (_a = wrapper.inject) === null || _a === void 0 ? void 0 : _a.map) === null || _b === void 0 ? void 0 : _b.call(_a, mapFactoryProviderInjectArray),
+            wrapper.inject?.map?.(mapFactoryProviderInjectArray),
             optionalDependenciesIds,
         ];
     }
@@ -197,15 +199,14 @@ class Injector {
         this.printResolvingDependenciesLog(token, inquirer);
         this.printLookingForProviderLog(token, moduleRef);
         const providers = moduleRef.providers;
-        const instanceWrapper = await this.lookupComponent(providers, moduleRef, Object.assign(Object.assign({}, dependencyContext), { name: token }), wrapper, contextId, inquirer, keyOrIndex);
+        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_2.STATIC_CONTEXT, inquirer) {
-        var _a;
         const inquirerId = this.getInquirerId(inquirer);
         const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
         if (!instanceHost.isResolved && !instanceWrapper.forwardRef) {
-            await this.loadProvider(instanceWrapper, (_a = instanceWrapper.host) !== null && _a !== void 0 ? _a : moduleRef, contextId, inquirer);
+            await this.loadProvider(instanceWrapper, instanceWrapper.host ?? moduleRef, contextId, inquirer);
         }
         else if (!instanceHost.isResolved &&
             instanceWrapper.forwardRef &&
@@ -317,12 +318,19 @@ class Injector {
                 return undefined;
             }
         }));
-        return properties.map((item, index) => (Object.assign(Object.assign({}, item), { instance: instances[index] })));
+        return properties.map((item, index) => ({
+            ...item,
+            instance: instances[index],
+        }));
     }
     reflectProperties(type) {
         const properties = Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, type) || [];
         const optionalKeys = Reflect.getMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, type) || [];
-        return properties.map((item) => (Object.assign(Object.assign({}, item), { name: item.type, isOptional: optionalKeys.includes(item.key) })));
+        return properties.map((item) => ({
+            ...item,
+            name: item.type,
+            isOptional: optionalKeys.includes(item.key),
+        }));
     }
     applyProperties(instance, properties) {
         if (!(0, shared_utils_1.isObject)(instance)) {
@@ -333,7 +341,6 @@ class Injector {
             .forEach(item => (instance[item.key] = item.instance));
     }
     async instantiateClass(instances, wrapper, targetMetatype, contextId = constants_2.STATIC_CONTEXT, inquirer) {
-        var _a, _b;
         const { metatype, inject } = wrapper;
         const inquirerId = this.getInquirerId(inquirer);
         const instanceHost = targetMetatype.getInstanceByContextId(this.getContextId(contextId, targetMetatype), inquirerId);
@@ -341,7 +348,7 @@ class Injector {
             wrapper.isInRequestScope(contextId, inquirer) ||
             wrapper.isLazyTransient(contextId, inquirer) ||
             wrapper.isExplicitlyRequested(contextId, inquirer);
-        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.preview) && !((_b = wrapper.host) === null || _b === void 0 ? void 0 : _b.initOnPreview)) {
+        if (this.options?.preview && !wrapper.host?.initOnPreview) {
             instanceHost.isResolved = true;
             return instanceHost.instance;
         }
@@ -378,7 +385,7 @@ class Injector {
     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 === null || item === void 0 ? void 0 : item.getInstanceByContextId(this.getContextId(contextId, item), inquirerId).instance);
+        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 }) => ({
@@ -418,32 +425,29 @@ class Injector {
         return (0, shared_utils_1.isFunction)(token) ? token.name : token.toString();
     }
     printResolvingDependenciesLog(token, inquirer) {
-        var _a, _b, _c;
         if (!this.isDebugMode()) {
             return;
         }
         const tokenName = this.getTokenName(token);
-        const dependentName = (_c = ((inquirer === null || inquirer === void 0 ? void 0 : inquirer.name) && ((_b = (_a = inquirer.name).toString) === null || _b === void 0 ? void 0 : _b.call(_a)))) !== null && _c !== void 0 ? _c : 'unknown';
+        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)' : ''}`)}`;
         this.logger.log(messageToPrint);
     }
     printLookingForProviderLog(token, moduleRef) {
-        var _a, _b;
         if (!this.isDebugMode()) {
             return;
         }
         const tokenName = this.getTokenName(token);
-        const moduleRefName = (_b = (_a = moduleRef === null || moduleRef === void 0 ? void 0 : moduleRef.metatype) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'unknown';
+        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)}`);
     }
     printFoundInModuleLog(token, moduleRef) {
-        var _a, _b;
         if (!this.isDebugMode()) {
             return;
         }
         const tokenName = this.getTokenName(token);
-        const moduleRefName = (_b = (_a = moduleRef === null || moduleRef === void 0 ? void 0 : moduleRef.metatype) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'unknown';
+        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() {

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

@@ -1,8 +1,8 @@
+import { InjectionToken } from '@nestjs/common';
 import { NestContainer } from './container';
 import { InstanceWrapper } from './instance-wrapper';
-import { InstanceToken } from './module';
 export interface InstanceLink<T = any> {
-    token: InstanceToken;
+    token: InjectionToken;
     wrapperRef: InstanceWrapper<T>;
     collection: Map<any, InstanceWrapper>;
     moduleId: string;
@@ -11,8 +11,8 @@ export declare class InstanceLinksHost {
     private readonly container;
     private readonly instanceLinks;
     constructor(container: NestContainer);
-    get<T = any>(token: InstanceToken): InstanceLink<T>;
-    get<T = any>(token: InstanceToken, options?: {
+    get<T = any>(token: InjectionToken): InstanceLink<T>;
+    get<T = any>(token: InjectionToken, options?: {
         moduleId?: string;
         each?: boolean;
     }): InstanceLink<T> | Array<InstanceLink<T>>;

package/injector/instance-links-host.js

@@ -50,7 +50,7 @@ class InstanceLinksHost {
         }
     }
     getInstanceNameByToken(token) {
-        return (0, shared_utils_1.isFunction)(token) ? token === null || token === void 0 ? void 0 : token.name : token;
+        return (0, shared_utils_1.isFunction)(token) ? token?.name : token;
     }
 }
 exports.InstanceLinksHost = InstanceLinksHost;