@nestjs/core 10.4.11 → 11.0.0-next.2

package/injector/helpers/silent-logger.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SilentLogger = void 0;
 const common_1 = require("@nestjs/common");
-// eslint-disable-next-line @typescript-eslint/no-empty-function
 const noop = () => { };
 class SilentLogger extends common_1.Logger {
     constructor() {

package/injector/injector.d.ts

@@ -1,5 +1,5 @@
 import { InjectionToken } from '@nestjs/common';
-import { Controller, Injectable, Type } from '@nestjs/common/interfaces';
+import { Controller, ForwardReference, Injectable, Type } from '@nestjs/common/interfaces';
 import { ContextId, InstancePerContext, InstanceWrapper, PropertyMetadata } from './instance-wrapper';
 import { Module } from './module';
 import { SettlementSignal } from './settlement-signal';
@@ -44,7 +44,7 @@ export declare class Injector {
     private logger;
     constructor(options?: {
         preview: boolean;
-    });
+    } | undefined);
     loadPrototype<T>({ token }: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper<T>>, contextId?: ContextId): void;
     loadInstance<T>(wrapper: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
     loadMiddleware(wrapper: InstanceWrapper, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
@@ -52,14 +52,14 @@ export declare class Injector {
     loadInjectable<T = any>(wrapper: InstanceWrapper<T>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
     loadProvider(wrapper: InstanceWrapper<Injectable>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
     applySettlementSignal<T>(instancePerContext: InstancePerContext<T>, host: InstanceWrapper<T>): SettlementSignal;
-    resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, moduleRef: Module, inject: InjectorDependency[], callback: (args: unknown[]) => void | Promise<void>, contextId?: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<void>;
+    resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, moduleRef: Module, inject: InjectorDependency[] | undefined, callback: (args: unknown[]) => void | Promise<void>, contextId?: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<void>;
     getClassDependencies<T>(wrapper: InstanceWrapper<T>): [InjectorDependency[], number[]];
     getFactoryProviderDependencies<T>(wrapper: InstanceWrapper<T>): [InjectorDependency[], number[]];
     reflectConstructorParams<T>(type: Type<T>): any[];
     reflectOptionalParams<T>(type: Type<T>): any[];
     reflectSelfParams<T>(type: Type<T>): any[];
-    resolveSingleParam<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol | any, dependencyContext: InjectorDependencyContext, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<any>>;
-    resolveParamToken<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol | any): any;
+    resolveSingleParam<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol, 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 | ForwardReference): any;
     resolveComponentInstance<T>(moduleRef: Module, token: InjectionToken, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper>;
     resolveComponentHost<T>(moduleRef: Module, instanceWrapper: InstanceWrapper<T | Promise<T>>, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<InstanceWrapper>;
     lookupComponent<T = any>(providers: Map<Function | string | symbol, InstanceWrapper>, moduleRef: Module, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<T>>;

package/injector/injector.js

@@ -202,11 +202,11 @@ class Injector {
         return this.resolveComponentInstance(moduleRef, token, dependencyContext, wrapper, contextId, inquirer, keyOrIndex);
     }
     resolveParamToken(wrapper, param) {
-        if (!param.forwardRef) {
-            return param;
+        if (typeof param === 'object' && 'forwardRef' in param) {
+            wrapper.forwardRef = true;
+            return param.forwardRef();
         }
-        wrapper.forwardRef = true;
-        return param.forwardRef();
+        return param;
     }
     async resolveComponentInstance(moduleRef, token, dependencyContext, wrapper, contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex) {
         this.printResolvingDependenciesLog(token, inquirer);
@@ -233,7 +233,7 @@ class Injector {
              * instantiated beforehand.
              */
             instanceHost.donePromise &&
-                instanceHost.donePromise.then(() => this.loadProvider(instanceWrapper, moduleRef, contextId, inquirer));
+                void instanceHost.donePromise.then(() => this.loadProvider(instanceWrapper, moduleRef, contextId, inquirer));
         }
         if (instanceWrapper.async) {
             const host = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
@@ -248,7 +248,7 @@ class Injector {
         if (wrapper && token === name) {
             throw new unknown_dependencies_exception_1.UnknownDependenciesException(wrapper.name, dependencyContext, moduleRef, { id: wrapper.id });
         }
-        if (providers.has(name)) {
+        if (name && providers.has(name)) {
             const instanceWrapper = providers.get(name);
             this.printFoundInModuleLog(name, moduleRef);
             this.addDependencyMetadata(keyOrIndex, wrapper, instanceWrapper);
@@ -415,7 +415,7 @@ class Injector {
         }));
     }
     getInquirerId(inquirer) {
-        return inquirer && inquirer.id;
+        return inquirer ? inquirer.id : undefined;
     }
     resolveScopedComponentHost(item, contextId, inquirer, parentInquirer) {
         return this.isInquirerRequest(item, parentInquirer)

package/injector/inquirer/inquirer-providers.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.inquirerProvider = void 0;
 const common_1 = require("@nestjs/common");
 const inquirer_constants_1 = require("./inquirer-constants");
-// eslint-disable-next-line @typescript-eslint/no-empty-function
 const noop = () => { };
 exports.inquirerProvider = {
     provide: inquirer_constants_1.INQUIRER,

package/injector/instance-wrapper.d.ts

@@ -38,8 +38,8 @@ export declare class InstanceWrapper<T = any> {
     readonly isAlias: boolean;
     readonly subtype?: EnhancerSubtype;
     scope?: Scope;
-    metatype: Type<T> | Function;
-    inject?: FactoryProvider['inject'];
+    metatype: Type<T> | Function | null;
+    inject?: FactoryProvider['inject'] | null;
     forwardRef?: boolean;
     durable?: boolean;
     initTime?: number;
@@ -76,11 +76,11 @@ export declare class InstanceWrapper<T = any> {
     cloneStaticInstance(contextId: ContextId): InstancePerContext<T>;
     cloneTransientInstance(contextId: ContextId, inquirerId: string): InstancePerContext<T>;
     createPrototype(contextId: ContextId): any;
-    isInRequestScope(contextId: ContextId, inquirer?: InstanceWrapper | undefined): boolean;
+    isInRequestScope(contextId: ContextId, inquirer?: InstanceWrapper): boolean;
     isLazyTransient(contextId: ContextId, inquirer: InstanceWrapper | undefined): boolean;
     isExplicitlyRequested(contextId: ContextId, inquirer?: InstanceWrapper): boolean;
     isStatic(contextId: ContextId, inquirer: InstanceWrapper | undefined): boolean;
-    getStaticTransientInstances(): InstancePerContext<T>[];
+    getStaticTransientInstances(): (InstancePerContext<T> | undefined)[];
     mergeWith(provider: Provider): void;
     private isNewable;
     private initialize;

package/injector/instance-wrapper.js

@@ -36,7 +36,7 @@ class InstanceWrapper {
         return !this.metatype || this.isFactory;
     }
     get isFactory() {
-        return this.metatype && !(0, shared_utils_1.isNil)(this.inject);
+        return !!this.metatype && !(0, shared_utils_1.isNil)(this.inject);
     }
     get isTransient() {
         return this.scope === common_1.Scope.TRANSIENT;
@@ -221,7 +221,7 @@ class InstanceWrapper {
             (!this.isTransient || (this.isTransient && !!inquirer)));
     }
     isLazyTransient(contextId, inquirer) {
-        const isInquirerRequestScoped = inquirer && !inquirer.isDependencyTreeStatic();
+        const isInquirerRequestScoped = !!(inquirer && !inquirer.isDependencyTreeStatic());
         return (this.isDependencyTreeStatic() &&
             contextId !== constants_1.STATIC_CONTEXT &&
             this.isTransient &&
@@ -231,7 +231,7 @@ class InstanceWrapper {
         const isSelfRequested = inquirer === this;
         return (this.isDependencyTreeStatic() &&
             contextId !== constants_1.STATIC_CONTEXT &&
-            (isSelfRequested || (inquirer && inquirer.scope === common_1.Scope.TRANSIENT)));
+            (isSelfRequested || !!(inquirer && inquirer.scope === common_1.Scope.TRANSIENT)));
     }
     isStatic(contextId, inquirer) {
         const isInquirerRequestScoped = inquirer && !inquirer.isDependencyTreeStatic();
@@ -278,7 +278,7 @@ class InstanceWrapper {
         const { instance, isResolved, ...wrapperPartial } = metadata;
         Object.assign(this, wrapperPartial);
         this.setInstanceByContextId(constants_1.STATIC_CONTEXT, {
-            instance,
+            instance: instance,
             isResolved,
         });
         this.scope === common_1.Scope.TRANSIENT && (this.transientMap = new Map());

package/injector/lazy-module-loader/lazy-module-loader.d.ts

@@ -12,7 +12,7 @@ export declare class LazyModuleLoader {
     private readonly moduleCompiler;
     private readonly modulesContainer;
     private readonly moduleOverrides?;
-    constructor(dependenciesScanner: DependenciesScanner, instanceLoader: InstanceLoader, moduleCompiler: ModuleCompiler, modulesContainer: ModulesContainer, moduleOverrides?: ModuleOverride[]);
+    constructor(dependenciesScanner: DependenciesScanner, instanceLoader: InstanceLoader, moduleCompiler: ModuleCompiler, modulesContainer: ModulesContainer, moduleOverrides?: ModuleOverride[] | undefined);
     load(loaderFn: () => Promise<Type<unknown> | DynamicModule> | Type<unknown> | DynamicModule, loadOpts?: LazyModuleLoaderLoadOptions): Promise<ModuleRef>;
     private registerLoggerConfiguration;
     private createLazyModulesContainer;

package/injector/module-ref.js

@@ -43,6 +43,7 @@ class ModuleRef extends abstract_instance_resolver_1.AbstractInstanceResolver {
             durable: (0, is_durable_1.isDurable)(type),
             host: moduleRef,
         });
+        /* eslint-disable-next-line no-async-promise-executor */
         return new Promise(async (resolve, reject) => {
             try {
                 const callback = async (instances) => {

package/injector/module.d.ts

@@ -56,8 +56,8 @@ export declare class Module {
     addCustomValue(provider: ValueProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
     addCustomFactory(provider: FactoryProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
     addCustomUseExisting(provider: ExistingProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
-    addExportedProvider(provider: Provider | string | symbol | DynamicModule): Set<InjectionToken>;
-    addCustomExportedProvider(provider: FactoryProvider | ValueProvider | ClassProvider | ExistingProvider): Set<InjectionToken>;
+    addExportedProvider(provider: Provider | string | symbol | DynamicModule): Set<InjectionToken> | undefined;
+    addCustomExportedProvider(provider: FactoryProvider | ValueProvider | ClassProvider | ExistingProvider): Set<InjectionToken> | undefined;
     validateExportedProvider(token: InjectionToken): InjectionToken;
     addController(controller: Type<Controller>): void;
     assignControllerUniqueId(controller: Type<Controller>): void;

package/injector/module.js

@@ -81,8 +81,8 @@ class Module {
         if (!this._providers.has(this._metatype)) {
             throw new exceptions_1.RuntimeException();
         }
-        const module = this._providers.get(this._metatype);
-        return module.instance;
+        const moduleRef = this._providers.get(this._metatype);
+        return moduleRef.instance;
     }
     get metatype() {
         return this._metatype;
@@ -418,7 +418,11 @@ class Module {
     }
     generateUuid() {
         const prefix = 'M_';
-        const key = this.name?.toString() ?? this.token?.toString();
+        const key = this.token
+            ? this.token.includes(':')
+                ? this.token.split(':')[1]
+                : this.token
+            : this.name;
         return key ? uuid_factory_1.UuidFactory.get(`${prefix}_${key}`) : (0, random_string_generator_util_1.randomStringGenerator)();
     }
     isTransientProvider(provider) {

package/injector/opaque-key-factory/by-reference-module-opaque-key-factory.d.ts

@@ -0,0 +1,15 @@
+import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
+import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+import { ModuleOpaqueKeyFactory } from './interfaces/module-opaque-key-factory.interface';
+export declare class ByReferenceModuleOpaqueKeyFactory implements ModuleOpaqueKeyFactory {
+    private readonly keyGenerationStrategy;
+    constructor(options?: {
+        keyGenerationStrategy: 'random' | 'shallow';
+    });
+    createForStatic(moduleCls: Type, originalRef?: Type | ForwardReference): string;
+    createForDynamic(moduleCls: Type<unknown>, dynamicMetadata: Omit<DynamicModule, 'module'>, originalRef: DynamicModule | ForwardReference): string;
+    private getOrCreateModuleId;
+    private hashString;
+    private generateRandomString;
+}

package/injector/opaque-key-factory/by-reference-module-opaque-key-factory.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByReferenceModuleOpaqueKeyFactory = void 0;
+const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
+const crypto_1 = require("crypto");
+const K_MODULE_ID = Symbol('K_MODULE_ID');
+class ByReferenceModuleOpaqueKeyFactory {
+    constructor(options) {
+        this.keyGenerationStrategy = options?.keyGenerationStrategy ?? 'random';
+    }
+    createForStatic(moduleCls, originalRef = moduleCls) {
+        return this.getOrCreateModuleId(moduleCls, undefined, originalRef);
+    }
+    createForDynamic(moduleCls, dynamicMetadata, originalRef) {
+        return this.getOrCreateModuleId(moduleCls, dynamicMetadata, originalRef);
+    }
+    getOrCreateModuleId(moduleCls, dynamicMetadata, originalRef) {
+        if (originalRef[K_MODULE_ID]) {
+            return originalRef[K_MODULE_ID];
+        }
+        let moduleId;
+        if (this.keyGenerationStrategy === 'random') {
+            moduleId = this.generateRandomString();
+        }
+        else {
+            moduleId = dynamicMetadata
+                ? `${this.generateRandomString()}:${this.hashString(moduleCls.name + JSON.stringify(dynamicMetadata))}`
+                : `${this.generateRandomString()}:${this.hashString(moduleCls.toString())}`;
+        }
+        originalRef[K_MODULE_ID] = moduleId;
+        return moduleId;
+    }
+    hashString(value) {
+        return (0, crypto_1.createHash)('sha256').update(value).digest('hex');
+    }
+    generateRandomString() {
+        return (0, random_string_generator_util_1.randomStringGenerator)();
+    }
+}
+exports.ByReferenceModuleOpaqueKeyFactory = ByReferenceModuleOpaqueKeyFactory;

package/injector/opaque-key-factory/deep-hashed-module-opaque-key-factory.d.ts

@@ -0,0 +1,15 @@
+import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+import { ModuleOpaqueKeyFactory } from './interfaces/module-opaque-key-factory.interface';
+export declare class DeepHashedModuleOpaqueKeyFactory implements ModuleOpaqueKeyFactory {
+    private readonly moduleIdsCache;
+    private readonly moduleTokenCache;
+    private readonly logger;
+    createForStatic(moduleCls: Type): string;
+    createForDynamic(moduleCls: Type<unknown>, dynamicMetadata: Omit<DynamicModule, 'module'>): string;
+    getStringifiedOpaqueToken(opaqueToken: object | undefined): string;
+    getModuleId(metatype: Type<unknown>): string;
+    getModuleName(metatype: Type<any>): string;
+    private hashString;
+    private replacer;
+}

package/injector/opaque-key-factory/deep-hashed-module-opaque-key-factory.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepHashedModuleOpaqueKeyFactory = void 0;
+const logger_service_1 = require("@nestjs/common/services/logger.service");
+const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const crypto_1 = require("crypto");
+const fast_safe_stringify_1 = require("fast-safe-stringify");
+const CLASS_STR = 'class ';
+const CLASS_STR_LEN = CLASS_STR.length;
+class DeepHashedModuleOpaqueKeyFactory {
+    constructor() {
+        this.moduleIdsCache = new WeakMap();
+        this.moduleTokenCache = new Map();
+        this.logger = new logger_service_1.Logger(DeepHashedModuleOpaqueKeyFactory.name, {
+            timestamp: true,
+        });
+    }
+    createForStatic(moduleCls) {
+        const moduleId = this.getModuleId(moduleCls);
+        const moduleName = this.getModuleName(moduleCls);
+        const key = `${moduleId}_${moduleName}`;
+        if (this.moduleTokenCache.has(key)) {
+            return this.moduleTokenCache.get(key);
+        }
+        const hash = this.hashString(key);
+        this.moduleTokenCache.set(key, hash);
+        return hash;
+    }
+    createForDynamic(moduleCls, dynamicMetadata) {
+        const moduleId = this.getModuleId(moduleCls);
+        const moduleName = this.getModuleName(moduleCls);
+        const opaqueToken = {
+            id: moduleId,
+            module: moduleName,
+            dynamic: dynamicMetadata,
+        };
+        const start = performance.now();
+        const opaqueTokenString = this.getStringifiedOpaqueToken(opaqueToken);
+        const timeSpentInMs = performance.now() - start;
+        if (timeSpentInMs > 10) {
+            const formattedTimeSpent = timeSpentInMs.toFixed(2);
+            this.logger.warn(`The module "${opaqueToken.module}" is taking ${formattedTimeSpent}ms to serialize, this may be caused by larger objects statically assigned to the module. Consider changing the "moduleIdGeneratorAlgorithm" option to "reference" to improve the performance.`);
+        }
+        return this.hashString(opaqueTokenString);
+    }
+    getStringifiedOpaqueToken(opaqueToken) {
+        // Uses safeStringify instead of JSON.stringify to support circular dynamic modules
+        // The replacer function is also required in order to obtain real class names
+        // instead of the unified "Function" key
+        return opaqueToken ? (0, fast_safe_stringify_1.default)(opaqueToken, this.replacer) : '';
+    }
+    getModuleId(metatype) {
+        let moduleId = this.moduleIdsCache.get(metatype);
+        if (moduleId) {
+            return moduleId;
+        }
+        moduleId = (0, random_string_generator_util_1.randomStringGenerator)();
+        this.moduleIdsCache.set(metatype, moduleId);
+        return moduleId;
+    }
+    getModuleName(metatype) {
+        return metatype.name;
+    }
+    hashString(value) {
+        return (0, crypto_1.createHash)('sha256').update(value).digest('hex');
+    }
+    replacer(key, value) {
+        if ((0, shared_utils_1.isFunction)(value)) {
+            const funcAsString = value.toString();
+            const isClass = funcAsString.slice(0, CLASS_STR_LEN) === CLASS_STR;
+            if (isClass) {
+                return value.name;
+            }
+            return funcAsString;
+        }
+        if ((0, shared_utils_1.isSymbol)(value)) {
+            return value.toString();
+        }
+        return value;
+    }
+}
+exports.DeepHashedModuleOpaqueKeyFactory = DeepHashedModuleOpaqueKeyFactory;

package/injector/opaque-key-factory/interfaces/module-opaque-key-factory.interface.d.ts

@@ -0,0 +1,18 @@
+import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
+import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+export interface ModuleOpaqueKeyFactory {
+    /**
+     * Creates a unique opaque key for the given static module.
+     * @param moduleCls A static module class.
+     * @param originalRef Original object reference. In most cases, it's the same as `moduleCls`.
+     */
+    createForStatic(moduleCls: Type, originalRef: Type | ForwardReference): string;
+    /**
+     * Creates a unique opaque key for the given dynamic module.
+     * @param moduleCls  A dynamic module class reference.
+     * @param dynamicMetadata Dynamic module metadata.
+     * @param originalRef Original object reference.
+     */
+    createForDynamic(moduleCls: Type<unknown>, dynamicMetadata: Omit<DynamicModule, 'module'>, originalRef: DynamicModule | ForwardReference): string;
+}

package/injector/opaque-key-factory/interfaces/module-opaque-key-factory.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/inspector/noop-graph-inspector.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoopGraphInspector = void 0;
 const graph_inspector_1 = require("./graph-inspector");
-// eslint-disable-next-line @typescript-eslint/no-empty-function
 const noop = () => { };
 exports.NoopGraphInspector = new Proxy(graph_inspector_1.GraphInspector.prototype, {
     get: () => noop,

package/inspector/serialized-graph.d.ts

@@ -17,7 +17,7 @@ export declare class SerializedGraph {
     private static readonly INTERNAL_PROVIDERS;
     set status(status: SerializedGraphStatus);
     set metadata(metadata: SerializedGraphMetadata);
-    insertNode(nodeDefinition: Node): Node;
+    insertNode(nodeDefinition: Node): Node | undefined;
     insertEdge(edgeDefinition: WithOptionalId<Edge>): {
         id: string;
         source: string;
@@ -44,7 +44,7 @@ export declare class SerializedGraph {
     insertEntrypoint<T>(definition: Entrypoint<T>, parentId: string): void;
     insertOrphanedEnhancer(entry: OrphanedEnhancerDefinition): void;
     insertAttachedEnhancer(nodeId: string): void;
-    getNodeById(id: string): Node;
+    getNodeById(id: string): Node | undefined;
     toJSON(): SerializedGraphJson;
     toString(): string;
     private generateUuidByEdgeDefinition;

package/interceptors/interceptors-context-creator.d.ts

@@ -7,7 +7,7 @@ export declare class InterceptorsContextCreator extends ContextCreator {
     private readonly container;
     private readonly config?;
     private moduleContext;
-    constructor(container: NestContainer, config?: ApplicationConfig);
+    constructor(container: NestContainer, config?: ApplicationConfig | undefined);
     create(instance: Controller, callback: (...args: unknown[]) => unknown, module: string, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): NestInterceptor[];
     createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): R;
     getInterceptorInstance(metatype: Function | NestInterceptor, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): NestInterceptor | null;

package/interceptors/interceptors-context-creator.js

@@ -23,11 +23,11 @@ class InterceptorsContextCreator extends context_creator_1.ContextCreator {
         return (0, iterare_1.iterate)(metadata)
             .filter(interceptor => interceptor && (interceptor.name || interceptor.intercept))
             .map(interceptor => this.getInterceptorInstance(interceptor, contextId, inquirerId))
-            .filter((interceptor) => interceptor && (0, shared_utils_1.isFunction)(interceptor.intercept))
+            .filter((interceptor) => interceptor ? (0, shared_utils_1.isFunction)(interceptor.intercept) : false)
             .toArray();
     }
     getInterceptorInstance(metatype, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
-        const isObject = metatype.intercept;
+        const isObject = !!metatype.intercept;
         if (isObject) {
             return metatype;
         }

package/metadata-scanner.d.ts

@@ -6,7 +6,7 @@ export declare class MetadataScanner {
      * @see {@link getAllMethodNames}
      * @see getAllMethodNames
      */
-    scanFromPrototype<T extends Injectable, R = any>(instance: T, prototype: object, callback: (name: string) => R): R[];
+    scanFromPrototype<T extends Injectable, R = any>(instance: T, prototype: object | null, callback: (name: string) => R): R[];
     /**
      * @deprecated
      * @see {@link getAllMethodNames}

package/middleware/builder.d.ts

@@ -8,7 +8,7 @@ export declare class MiddlewareBuilder implements MiddlewareConsumer {
     private readonly routeInfoPathExtractor;
     private readonly middlewareCollection;
     constructor(routesMapper: RoutesMapper, httpAdapter: HttpServer, routeInfoPathExtractor: RouteInfoPathExtractor);
-    apply(...middleware: Array<Type<any> | Function | any>): MiddlewareConfigProxy;
+    apply(...middleware: Array<Type<any> | Function | Array<Type<any> | Function>>): MiddlewareConfigProxy;
     build(): MiddlewareConfiguration[];
     getHttpAdapter(): HttpServer;
     private static readonly ConfigProxy;

package/middleware/builder.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MiddlewareBuilder = void 0;
-const dependencies_decorator_1 = require("@nestjs/common/decorators/core/dependencies.decorator");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const iterare_1 = require("iterare");
 const utils_1 = require("./utils");
@@ -13,7 +12,7 @@ class MiddlewareBuilder {
         this.middlewareCollection = new Set();
     }
     apply(...middleware) {
-        return new MiddlewareBuilder.ConfigProxy(this, (0, dependencies_decorator_1.flatten)(middleware), this.routeInfoPathExtractor);
+        return new MiddlewareBuilder.ConfigProxy(this, middleware.flat(), this.routeInfoPathExtractor);
     }
     build() {
         return [...this.middlewareCollection];
@@ -67,7 +66,7 @@ MiddlewareBuilder.ConfigProxy = class {
             .toArray();
     }
     removeOverlappedRoutes(routes) {
-        const regexMatchParams = /(:[^\/]*)/g;
+        const regexMatchParams = /(:[^/]*)/g;
         const wildcard = '([^/]*)';
         const routesWithRegex = routes
             .filter(route => route.path.includes(':'))

package/middleware/middleware-module.js

@@ -162,7 +162,7 @@ class MiddlewareModule {
         const middlewareFunction = isMethodAll
             ? proxy
             : (req, res, next) => {
-                if (applicationRef.getRequestMethod(req) === requestMethod) {
+                if (applicationRef.getRequestMethod?.(req) === requestMethod) {
                     return proxy(req, res, next);
                 }
                 return next();

package/middleware/route-info-path-extractor.js

@@ -30,7 +30,11 @@ class RouteInfoPathExtractor {
             return Array.isArray(this.excludedGlobalPrefixRoutes)
                 ? [
                     ...entries,
-                    ...this.excludedGlobalPrefixRoutes.map(route => versionPaths + (0, shared_utils_1.addLeadingSlash)(route.path)),
+                    ...this.excludedGlobalPrefixRoutes
+                        .map(route => Array.isArray(versionPaths) && versionPaths.length > 0
+                        ? versionPaths.map(v => v + (0, shared_utils_1.addLeadingSlash)(route.path))
+                        : (0, shared_utils_1.addLeadingSlash)(route.path))
+                        .flat(),
                 ]
                 : entries;
         }
@@ -43,7 +47,7 @@ class RouteInfoPathExtractor {
         return this.extractNonWildcardPathsFrom(route);
     }
     isAWildcard(path) {
-        return ['*', '/*', '/*/', '(.*)', '/(.*)'].includes(path);
+        return ['*', '/*', '/*/', '*path', '/*path', '(.*)', '/(.*)'].includes(path);
     }
     extractNonWildcardPathsFrom({ path, method, version, }) {
         const versionPaths = this.extractVersionPathFrom(version);

package/middleware/utils.js

@@ -7,23 +7,34 @@ exports.isMiddlewareRouteExcluded = isMiddlewareRouteExcluded;
 const common_1 = require("@nestjs/common");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const iterare_1 = require("iterare");
-const pathToRegexp = require("path-to-regexp");
+const path_to_regexp_1 = require("path-to-regexp");
 const uid_1 = require("uid");
+const legacy_route_converter_1 = require("../router/legacy-route-converter");
 const utils_1 = require("../router/utils");
 const mapToExcludeRoute = (routes) => {
     return routes.map(route => {
-        if ((0, shared_utils_1.isString)(route)) {
+        const originalPath = (0, shared_utils_1.isString)(route) ? route : route.path;
+        const path = legacy_route_converter_1.LegacyRouteConverter.tryConvert(originalPath);
+        try {
+            if ((0, shared_utils_1.isString)(route)) {
+                return {
+                    path,
+                    requestMethod: common_1.RequestMethod.ALL,
+                    pathRegex: (0, path_to_regexp_1.pathToRegexp)((0, shared_utils_1.addLeadingSlash)(path)).regexp,
+                };
+            }
             return {
-                path: route,
-                requestMethod: common_1.RequestMethod.ALL,
-                pathRegex: pathToRegexp((0, shared_utils_1.addLeadingSlash)(route)),
+                path,
+                requestMethod: route.method,
+                pathRegex: (0, path_to_regexp_1.pathToRegexp)((0, shared_utils_1.addLeadingSlash)(path)).regexp,
             };
         }
-        return {
-            path: route.path,
-            requestMethod: route.method,
-            pathRegex: pathToRegexp((0, shared_utils_1.addLeadingSlash)(route.path)),
-        };
+        catch (e) {
+            if (e instanceof TypeError) {
+                legacy_route_converter_1.LegacyRouteConverter.printError(originalPath);
+            }
+            throw e;
+        }
     });
 };
 exports.mapToExcludeRoute = mapToExcludeRoute;
@@ -87,7 +98,7 @@ function isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter) {
     }
     const reqMethod = httpAdapter.getRequestMethod(req);
     const originalUrl = httpAdapter.getRequestUrl(req);
-    const queryParamsIndex = originalUrl && originalUrl.indexOf('?');
+    const queryParamsIndex = originalUrl ? originalUrl.indexOf('?') : -1;
     const pathname = queryParamsIndex >= 0
         ? originalUrl.slice(0, queryParamsIndex)
         : originalUrl;

package/nest-application-context.d.ts

@@ -1,5 +1,5 @@
 import { INestApplicationContext, Logger, LoggerService, LogLevel, ShutdownSignal } from '@nestjs/common';
-import { DynamicModule, Type } from '@nestjs/common/interfaces';
+import { DynamicModule, SelectOptions, Type } from '@nestjs/common/interfaces';
 import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
 import { AbstractInstanceResolver } from './injector/abstract-instance-resolver';
 import { NestContainer } from './injector/container';
@@ -26,13 +26,13 @@ export declare class NestApplicationContext<TOptions extends NestApplicationCont
     private _moduleRefsForHooksByDistance?;
     private initializationPromise?;
     protected get instanceLinksHost(): InstanceLinksHost;
-    constructor(container: NestContainer, appOptions?: TOptions, contextModule?: Module, scope?: Type<any>[]);
+    constructor(container: NestContainer, appOptions?: TOptions, contextModule?: Module | null, scope?: Type<any>[]);
     selectContextModule(): void;
     /**
      * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
      * @returns {INestApplicationContext}
      */
-    select<T>(moduleType: Type<T> | DynamicModule): INestApplicationContext;
+    select<T>(moduleType: Type<T> | DynamicModule, selectOptions?: SelectOptions): INestApplicationContext;
     /**
      * Retrieves an instance of either injectable or controller, otherwise, throws exception.
      * @returns {TResult}