@nestjs/core 10.4.10 → 11.0.0-next.1

package/adapters/http-adapter.d.ts

@@ -23,6 +23,20 @@ export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any,
     put(path: any, handler: RequestHandler): any;
     patch(handler: RequestHandler): any;
     patch(path: any, handler: RequestHandler): any;
+    propfind(handler: RequestHandler): any;
+    propfind(path: any, handler: RequestHandler): any;
+    proppatch(handler: RequestHandler): any;
+    proppatch(path: any, handler: RequestHandler): any;
+    mkcol(handler: RequestHandler): any;
+    mkcol(path: any, handler: RequestHandler): any;
+    copy(handler: RequestHandler): any;
+    copy(path: any, handler: RequestHandler): any;
+    move(handler: RequestHandler): any;
+    move(path: any, handler: RequestHandler): any;
+    lock(handler: RequestHandler): any;
+    lock(path: any, handler: RequestHandler): any;
+    unlock(handler: RequestHandler): any;
+    unlock(path: any, handler: RequestHandler): any;
     all(handler: RequestHandler): any;
     all(path: any, handler: RequestHandler): any;
     search(handler: RequestHandler): any;

package/adapters/http-adapter.js

@@ -8,7 +8,6 @@ class AbstractHttpAdapter {
     constructor(instance) {
         this.instance = instance;
     }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
     async init() { }
     use(...args) {
         return this.instance.use(...args);
@@ -31,6 +30,27 @@ class AbstractHttpAdapter {
     patch(...args) {
         return this.instance.patch(...args);
     }
+    propfind(...args) {
+        return this.instance.propfind(...args);
+    }
+    proppatch(...args) {
+        return this.instance.proppatch(...args);
+    }
+    mkcol(...args) {
+        return this.instance.mkcol(...args);
+    }
+    copy(...args) {
+        return this.instance.copy(...args);
+    }
+    move(...args) {
+        return this.instance.move(...args);
+    }
+    lock(...args) {
+        return this.instance.lock(...args);
+    }
+    unlock(...args) {
+        return this.instance.unlock(...args);
+    }
     all(...args) {
         return this.instance.all(...args);
     }

package/errors/exception-handler.d.ts

@@ -1,5 +1,4 @@
-import { RuntimeException } from './exceptions/runtime.exception';
 export declare class ExceptionHandler {
     private static readonly logger;
-    handle(exception: RuntimeException | Error): void;
+    handle(exception: Error): void;
 }

package/errors/exception-handler.js

@@ -1,15 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExceptionHandler = void 0;
-const runtime_exception_1 = require("./exceptions/runtime.exception");
 const logger_service_1 = require("@nestjs/common/services/logger.service");
 class ExceptionHandler {
     handle(exception) {
-        if (!(exception instanceof runtime_exception_1.RuntimeException)) {
-            ExceptionHandler.logger.error(exception.message, exception.stack);
-            return;
-        }
-        ExceptionHandler.logger.error(exception.what(), exception.stack);
+        ExceptionHandler.logger.error(exception);
     }
 }
 exports.ExceptionHandler = ExceptionHandler;

package/errors/exceptions/undefined-dependency.exception.d.ts

@@ -1,6 +1,6 @@
 import { InjectorDependencyContext } from '../../injector/injector';
-import { RuntimeException } from './runtime.exception';
 import { Module } from '../../injector/module';
+import { RuntimeException } from './runtime.exception';
 export declare class UndefinedDependencyException extends RuntimeException {
-    constructor(type: string, undefinedDependencyContext: InjectorDependencyContext, module?: Module);
+    constructor(type: string, undefinedDependencyContext: InjectorDependencyContext, moduleRef?: Module);
 }

package/errors/exceptions/undefined-dependency.exception.js

@@ -4,8 +4,8 @@ exports.UndefinedDependencyException = void 0;
 const messages_1 = require("../messages");
 const runtime_exception_1 = require("./runtime.exception");
 class UndefinedDependencyException extends runtime_exception_1.RuntimeException {
-    constructor(type, undefinedDependencyContext, module) {
-        super((0, messages_1.UNKNOWN_DEPENDENCIES_MESSAGE)(type, undefinedDependencyContext, module));
+    constructor(type, undefinedDependencyContext, moduleRef) {
+        super((0, messages_1.UNKNOWN_DEPENDENCIES_MESSAGE)(type, undefinedDependencyContext, moduleRef));
     }
 }
 exports.UndefinedDependencyException = UndefinedDependencyException;

package/errors/exceptions/unknown-dependencies.exception.d.ts

@@ -6,11 +6,11 @@ export declare class UnknownDependenciesException extends RuntimeException {
     readonly context: InjectorDependencyContext;
     readonly metadata?: {
         id: string;
-    };
+    } | undefined;
     readonly moduleRef: {
         id: string;
     } | undefined;
     constructor(type: string | symbol, context: InjectorDependencyContext, moduleRef?: Module, metadata?: {
         id: string;
-    });
+    } | undefined);
 }

package/errors/exceptions-zone.d.ts

@@ -1,5 +1,5 @@
 export declare class ExceptionsZone {
     private static readonly exceptionHandler;
-    static run(callback: () => void, teardown: (err: any) => void, autoFlushLogs: boolean): void;
-    static asyncRun(callback: () => Promise<void>, teardown: (err: any) => void, autoFlushLogs: boolean): Promise<void>;
+    static run(callback: () => void, teardown: ((err: any) => void) | undefined, autoFlushLogs: boolean): void;
+    static asyncRun(callback: () => Promise<void>, teardown: ((err: any) => void) | undefined, autoFlushLogs: boolean): Promise<void>;
 }

package/errors/messages.d.ts

@@ -1,13 +1,13 @@
 import type { ForwardReference, Type } from '@nestjs/common';
 import { InjectorDependencyContext } from '../injector/injector';
 import { Module } from '../injector/module';
-export declare const UNKNOWN_DEPENDENCIES_MESSAGE: (type: string | symbol, unknownDependencyContext: InjectorDependencyContext, module: Module) => string;
+export declare const UNKNOWN_DEPENDENCIES_MESSAGE: (type: string | symbol, unknownDependencyContext: InjectorDependencyContext, moduleRef: Module | undefined) => string;
 export declare const INVALID_MIDDLEWARE_MESSAGE: (text: TemplateStringsArray, name: string) => string;
 export declare const UNDEFINED_FORWARDREF_MESSAGE: (scope: Type<any>[]) => string;
 export declare const INVALID_MODULE_MESSAGE: (parentModule: any, index: number, scope: any[]) => string;
 export declare const USING_INVALID_CLASS_AS_A_MODULE_MESSAGE: (metatypeUsedAsAModule: Type | ForwardReference, scope: any[]) => string;
 export declare const UNDEFINED_MODULE_MESSAGE: (parentModule: any, index: number, scope: any[]) => string;
-export declare const UNKNOWN_EXPORT_MESSAGE: (token: string | symbol, module: string) => string;
+export declare const UNKNOWN_EXPORT_MESSAGE: (token: (string | symbol) | undefined, module: string) => string;
 export declare const INVALID_CLASS_MESSAGE: (text: TemplateStringsArray, value: any) => string;
 export declare const INVALID_CLASS_SCOPE_MESSAGE: (text: TemplateStringsArray, name: string | undefined) => string;
 export declare const UNKNOWN_REQUEST_MAPPING: (metatype: Type) => string;

package/errors/messages.js

@@ -44,9 +44,9 @@ getInstanceName(dependency) ||
  */
 const getModuleName = (module) => (module && getInstanceName(module.metatype)) || 'current';
 const stringifyScope = (scope) => (scope || []).map(getInstanceName).join(' -> ');
-const UNKNOWN_DEPENDENCIES_MESSAGE = (type, unknownDependencyContext, module) => {
+const UNKNOWN_DEPENDENCIES_MESSAGE = (type, unknownDependencyContext, moduleRef) => {
     const { index, name, dependencies, key } = unknownDependencyContext;
-    const moduleName = getModuleName(module);
+    const moduleName = getModuleName(moduleRef);
     const dependencyName = getDependencyName(name, 'dependency');
     const potentialSolutions = 
     // If module's name is well defined
@@ -99,7 +99,7 @@ Scope [${stringifyScope(scope)}]`;
 };
 exports.INVALID_MODULE_MESSAGE = INVALID_MODULE_MESSAGE;
 const USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = (metatypeUsedAsAModule, scope) => {
-    const metatypeNameQuote = `"${getInstanceName(metatypeUsedAsAModule)}"` || 'that class';
+    const metatypeNameQuote = `"${getInstanceName(metatypeUsedAsAModule)}"`;
     return `Classes annotated with @Injectable(), @Catch(), and @Controller() decorators must not appear in the "imports" array of a module.
 Please remove ${metatypeNameQuote} (including forwarded occurrences, if any) from all of the "imports" arrays.
 

package/exceptions/base-exception-filter-context.js

@@ -26,7 +26,7 @@ class BaseExceptionFilterContext extends context_creator_1.ContextCreator {
             .toArray();
     }
     getFilterInstance(filter, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
-        const isObject = filter.catch;
+        const isObject = !!filter.catch;
         if (isObject) {
             return filter;
         }

package/exceptions/base-exception-filter.d.ts

@@ -2,10 +2,10 @@ import { ArgumentsHost, ExceptionFilter, HttpServer } from '@nestjs/common';
 import { AbstractHttpAdapter } from '../adapters';
 import { HttpAdapterHost } from '../helpers/http-adapter-host';
 export declare class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {
-    protected readonly applicationRef?: HttpServer;
+    protected readonly applicationRef?: HttpServer | undefined;
     private static readonly logger;
     protected readonly httpAdapterHost?: HttpAdapterHost;
-    constructor(applicationRef?: HttpServer);
+    constructor(applicationRef?: HttpServer | undefined);
     catch(exception: T, host: ArgumentsHost): void;
     handleUnknownError(exception: T, host: ArgumentsHost, applicationRef: AbstractHttpAdapter | HttpServer): void;
     isExceptionObject(err: any): err is Error;

package/exceptions/base-exception-filter.js

@@ -48,10 +48,9 @@ class BaseExceptionFilter {
         else {
             applicationRef.end(response);
         }
-        if (this.isExceptionObject(exception)) {
-            return BaseExceptionFilter.logger.error(exception.message, exception.stack);
+        if (!(exception instanceof common_1.IntrinsicException)) {
+            BaseExceptionFilter.logger.error(exception);
         }
-        return BaseExceptionFilter.logger.error(exception);
     }
     isExceptionObject(err) {
         return (0, shared_utils_1.isObject)(err) && !!err.message;

package/exceptions/exceptions-handler.d.ts

@@ -1,10 +1,10 @@
 import { HttpException } from '@nestjs/common';
-import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
 import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions/exception-filter-metadata.interface';
+import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
 import { BaseExceptionFilter } from './base-exception-filter';
 export declare class ExceptionsHandler extends BaseExceptionFilter {
     private filters;
-    next(exception: Error | HttpException | any, ctx: ArgumentsHost): void;
+    next(exception: Error | HttpException, ctx: ArgumentsHost): void;
     setCustomFilters(filters: ExceptionFilterMetadata[]): void;
     invokeCustomFilters<T = any>(exception: T, ctx: ArgumentsHost): boolean;
 }

package/exceptions/exceptions-handler.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExceptionsHandler = void 0;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 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 shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
+const base_exception_filter_1 = require("./base-exception-filter");
 class ExceptionsHandler extends base_exception_filter_1.BaseExceptionFilter {
     constructor() {
         super(...arguments);

package/exceptions/external-exception-filter-context.d.ts

@@ -6,7 +6,7 @@ import { BaseExceptionFilterContext } from './base-exception-filter-context';
 import { ExternalExceptionsHandler } from './external-exceptions-handler';
 export declare class ExternalExceptionFilterContext extends BaseExceptionFilterContext {
     private readonly config?;
-    constructor(container: NestContainer, config?: ApplicationConfig);
+    constructor(container: NestContainer, config?: ApplicationConfig | undefined);
     create(instance: Controller, callback: RouterProxyCallback, module: string, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): ExternalExceptionsHandler;
     getGlobalMetadata<T extends any[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
 }

package/exceptions/external-exception-filter-context.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExternalExceptionFilterContext = void 0;
 const constants_1 = require("@nestjs/common/constants");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
 const constants_2 = require("../injector/constants");
 const base_exception_filter_context_1 = require("./base-exception-filter-context");
 const external_exceptions_handler_1 = require("./external-exceptions-handler");
-const iterare_1 = require("iterare");
 class ExternalExceptionFilterContext extends base_exception_filter_context_1.BaseExceptionFilterContext {
     constructor(container, config) {
         super(container);

package/exceptions/external-exception-filter.js

@@ -4,8 +4,9 @@ exports.ExternalExceptionFilter = void 0;
 const common_1 = require("@nestjs/common");
 class ExternalExceptionFilter {
     catch(exception, host) {
-        if (exception instanceof Error && !(exception instanceof common_1.HttpException)) {
-            ExternalExceptionFilter.logger.error(exception.message, exception.stack);
+        if (exception instanceof Error &&
+            !(exception instanceof common_1.IntrinsicException)) {
+            ExternalExceptionFilter.logger.error(exception);
         }
         throw exception;
     }

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

@@ -1,9 +1,9 @@
-import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
 import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions';
+import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
 import { ExternalExceptionFilter } from './external-exception-filter';
 export declare class ExternalExceptionsHandler extends ExternalExceptionFilter {
     private filters;
-    next(exception: Error | any, host: ArgumentsHost): Promise<any>;
+    next(exception: Error, host: ArgumentsHost): Promise<any>;
     setCustomFilters(filters: ExceptionFilterMetadata[]): void;
     invokeCustomFilters<T = any>(exception: T, host: ArgumentsHost): Promise<any> | null;
 }

package/exceptions/external-exceptions-handler.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExternalExceptionsHandler = void 0;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 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 shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
+const external_exception_filter_1 = require("./external-exception-filter");
 class ExternalExceptionsHandler extends external_exception_filter_1.ExternalExceptionFilter {
     constructor() {
         super(...arguments);

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

@@ -8,7 +8,7 @@ export declare class GuardsContextCreator 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): CanActivate[];
     createConcreteContext<T extends unknown[], R extends unknown[]>(metadata: T, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): R;
     getGuardInstance(metatype: Function | CanActivate, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): CanActivate | null;

package/guards/guards-context-creator.js

@@ -23,11 +23,11 @@ class GuardsContextCreator extends context_creator_1.ContextCreator {
         return (0, iterare_1.iterate)(metadata)
             .filter((guard) => guard && (guard.name || guard.canActivate))
             .map(guard => this.getGuardInstance(guard, contextId, inquirerId))
-            .filter((guard) => guard && (0, shared_utils_1.isFunction)(guard.canActivate))
+            .filter((guard) => !!guard && (0, shared_utils_1.isFunction)(guard.canActivate))
             .toArray();
     }
     getGuardInstance(metatype, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
-        const isObject = metatype.canActivate;
+        const isObject = !!metatype.canActivate;
         if (isObject) {
             return metatype;
         }

package/helpers/execution-context-host.d.ts

@@ -6,7 +6,7 @@ export declare class ExecutionContextHost implements ExecutionContext {
     private readonly constructorRef;
     private readonly handler;
     private contextType;
-    constructor(args: any[], constructorRef?: Type<any>, handler?: Function);
+    constructor(args: any[], constructorRef?: Type<any> | null, handler?: Function | null);
     setType<TContext extends string = ContextType>(type: TContext): void;
     getType<TContext extends string = ContextType>(): TContext;
     getClass<T = any>(): Type<T>;

package/helpers/external-context-creator.d.ts

@@ -39,7 +39,7 @@ export declare class ExternalContextCreator {
     exchangeKeysForValues<TMetadata = any>(keys: string[], metadata: TMetadata, moduleContext: string, paramsFactory: ParamsFactory, contextId?: ContextId, inquirerId?: string, contextFactory?: (args: unknown[]) => import("./execution-context-host").ExecutionContextHost): ParamProperties[];
     createPipesFn(pipes: PipeTransform[], paramsOptions: (ParamProperties & {
         metatype?: unknown;
-    })[]): (args: unknown[], ...params: unknown[]) => Promise<void>;
+    })[]): ((args: unknown[], ...params: unknown[]) => Promise<void>) | null;
     getParamValue<T>(value: T, { metatype, type, data }: {
         metatype: any;
         type: any;

package/helpers/external-context-creator.js

@@ -6,8 +6,8 @@ const constants_1 = require("@nestjs/common/constants");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const rxjs_1 = require("rxjs");
 const external_exception_filter_context_1 = require("../exceptions/external-exception-filter-context");
-const constants_2 = require("../guards/constants");
 const guards_1 = require("../guards");
+const constants_2 = require("../guards/constants");
 const constants_3 = require("../injector/constants");
 const interceptors_1 = require("../interceptors");
 const pipes_1 = require("../pipes");
@@ -45,15 +45,15 @@ class ExternalContextCreator {
         guards: true,
         filters: true,
     }, contextType = 'http') {
-        const module = this.getContextModuleKey(instance.constructor);
+        const moduleKey = this.getContextModuleKey(instance.constructor);
         const { argsLength, paramtypes, getParamsMetadata } = this.getMetadata(instance, methodName, metadataKey, paramsFactory, contextType);
-        const pipes = this.pipesContextCreator.create(instance, callback, module, contextId, inquirerId);
-        const guards = this.guardsContextCreator.create(instance, callback, module, contextId, inquirerId);
-        const exceptionFilter = this.filtersContextCreator.create(instance, callback, module, contextId, inquirerId);
+        const pipes = this.pipesContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+        const guards = this.guardsContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+        const exceptionFilter = this.filtersContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
         const interceptors = options.interceptors
-            ? this.interceptorsContextCreator.create(instance, callback, module, contextId, inquirerId)
+            ? this.interceptorsContextCreator.create(instance, callback, moduleKey, contextId, inquirerId)
             : [];
-        const paramsMetadata = getParamsMetadata(module, contextId, inquirerId);
+        const paramsMetadata = getParamsMetadata(moduleKey, contextId, inquirerId);
         const paramsOptions = paramsMetadata
             ? this.contextUtils.mergeParamsMetatypes(paramsMetadata, paramtypes)
             : [];
@@ -94,7 +94,7 @@ class ExternalContextCreator {
         const handlerMetadata = {
             argsLength,
             paramtypes,
-            getParamsMetadata,
+            getParamsMetadata: getParamsMetadata,
         };
         this.handlerMetadataStorage.set(instance, methodName, handlerMetadata);
         return handlerMetadata;

package/helpers/router-method-factory.js

@@ -12,6 +12,13 @@ const REQUEST_METHOD_MAP = {
     [request_method_enum_1.RequestMethod.OPTIONS]: 'options',
     [request_method_enum_1.RequestMethod.HEAD]: 'head',
     [request_method_enum_1.RequestMethod.SEARCH]: 'search',
+    [request_method_enum_1.RequestMethod.PROPFIND]: 'propfind',
+    [request_method_enum_1.RequestMethod.PROPPATCH]: 'proppatch',
+    [request_method_enum_1.RequestMethod.MKCOL]: 'mkcol',
+    [request_method_enum_1.RequestMethod.COPY]: 'copy',
+    [request_method_enum_1.RequestMethod.MOVE]: 'move',
+    [request_method_enum_1.RequestMethod.LOCK]: 'lock',
+    [request_method_enum_1.RequestMethod.UNLOCK]: 'unlock',
 };
 class RouterMethodFactory {
     get(target, requestMethod) {

package/injector/abstract-instance-resolver.js

@@ -25,12 +25,12 @@ class AbstractInstanceResolver {
                 each: options.each,
             })
             : this.instanceLinksHost.get(typeOrToken, {
-                each: options.each,
+                each: options?.each,
             });
         const pluckInstance = async (instanceLink) => {
             const { wrapperRef, collection } = instanceLink;
             if (wrapperRef.isDependencyTreeStatic() && !wrapperRef.isTransient) {
-                return this.get(typeOrToken, { strict: options.strict });
+                return this.get(typeOrToken, { strict: options?.strict });
             }
             const ctorHost = wrapperRef.instance || { constructor: typeOrToken };
             const instance = await this.injector.loadPerContext(ctorHost, wrapperRef.host, collection, contextId, wrapperRef);

package/injector/compiler.d.ts

@@ -1,17 +1,18 @@
 import { DynamicModule, ForwardReference, Type } from '@nestjs/common/interfaces';
-import { ModuleTokenFactory } from './module-token-factory';
+import { ModuleOpaqueKeyFactory } from './opaque-key-factory/interfaces/module-opaque-key-factory.interface';
 export interface ModuleFactory {
     type: Type<any>;
     token: string;
     dynamicMetadata?: Partial<DynamicModule>;
 }
 export declare class ModuleCompiler {
-    private readonly moduleTokenFactory;
-    constructor(moduleTokenFactory?: ModuleTokenFactory);
-    compile(metatype: Type<any> | DynamicModule | Promise<DynamicModule>): Promise<ModuleFactory>;
-    extractMetadata(metatype: Type<any> | ForwardReference | DynamicModule): {
-        type: Type<any>;
-        dynamicMetadata?: Partial<DynamicModule> | undefined;
+    private readonly _moduleOpaqueKeyFactory;
+    constructor(_moduleOpaqueKeyFactory: ModuleOpaqueKeyFactory);
+    get moduleOpaqueKeyFactory(): ModuleOpaqueKeyFactory;
+    compile(moduleClsOrDynamic: Type | DynamicModule | ForwardReference | Promise<DynamicModule>): Promise<ModuleFactory>;
+    extractMetadata(moduleClsOrDynamic: Type | ForwardReference | DynamicModule): {
+        type: Type;
+        dynamicMetadata: Omit<DynamicModule, 'module'> | undefined;
     };
-    isDynamicModule(module: Type<any> | DynamicModule | ForwardReference): module is DynamicModule;
+    isDynamicModule(moduleClsOrDynamic: Type | DynamicModule | ForwardReference): moduleClsOrDynamic is DynamicModule;
 }

package/injector/compiler.js

@@ -1,29 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleCompiler = void 0;
-const module_token_factory_1 = require("./module-token-factory");
 class ModuleCompiler {
-    constructor(moduleTokenFactory = new module_token_factory_1.ModuleTokenFactory()) {
-        this.moduleTokenFactory = moduleTokenFactory;
+    constructor(_moduleOpaqueKeyFactory) {
+        this._moduleOpaqueKeyFactory = _moduleOpaqueKeyFactory;
     }
-    async compile(metatype) {
-        const { type, dynamicMetadata } = this.extractMetadata(await metatype);
-        const token = this.moduleTokenFactory.create(type, dynamicMetadata);
+    get moduleOpaqueKeyFactory() {
+        return this._moduleOpaqueKeyFactory;
+    }
+    async compile(moduleClsOrDynamic) {
+        moduleClsOrDynamic = await moduleClsOrDynamic;
+        const { type, dynamicMetadata } = this.extractMetadata(moduleClsOrDynamic);
+        const token = dynamicMetadata
+            ? this._moduleOpaqueKeyFactory.createForDynamic(type, dynamicMetadata, moduleClsOrDynamic)
+            : this._moduleOpaqueKeyFactory.createForStatic(type, moduleClsOrDynamic);
         return { type, dynamicMetadata, token };
     }
-    extractMetadata(metatype) {
-        if (!this.isDynamicModule(metatype)) {
+    extractMetadata(moduleClsOrDynamic) {
+        if (!this.isDynamicModule(moduleClsOrDynamic)) {
             return {
-                type: metatype?.forwardRef
-                    ? metatype.forwardRef()
-                    : metatype,
+                type: moduleClsOrDynamic?.forwardRef
+                    ? moduleClsOrDynamic.forwardRef()
+                    : moduleClsOrDynamic,
+                dynamicMetadata: undefined,
             };
         }
-        const { module: type, ...dynamicMetadata } = metatype;
+        const { module: type, ...dynamicMetadata } = moduleClsOrDynamic;
         return { type, dynamicMetadata };
     }
-    isDynamicModule(module) {
-        return !!module.module;
+    isDynamicModule(moduleClsOrDynamic) {
+        return !!moduleClsOrDynamic.module;
     }
 }
 exports.ModuleCompiler = ModuleCompiler;

package/injector/container.d.ts

@@ -1,26 +1,27 @@
 import { DynamicModule, Provider } from '@nestjs/common';
 import { EnhancerSubtype } from '@nestjs/common/constants';
 import { Injectable, Type } from '@nestjs/common/interfaces';
+import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
 import { ApplicationConfig } from '../application-config';
 import { SerializedGraph } from '../inspector/serialized-graph';
 import { ModuleCompiler } from './compiler';
 import { ContextId } from './instance-wrapper';
 import { Module } from './module';
-import { ModuleTokenFactory } from './module-token-factory';
 import { ModulesContainer } from './modules-container';
+import { ModuleOpaqueKeyFactory } from './opaque-key-factory/interfaces/module-opaque-key-factory.interface';
 type ModuleMetatype = Type<any> | DynamicModule | Promise<DynamicModule>;
 type ModuleScope = Type<any>[];
 export declare class NestContainer {
     private readonly _applicationConfig;
+    private readonly _contextOptions;
     private readonly globalModules;
-    private readonly moduleTokenFactory;
-    private readonly moduleCompiler;
     private readonly modules;
     private readonly dynamicModulesMetadata;
     private readonly internalProvidersStorage;
     private readonly _serializedGraph;
+    private moduleCompiler;
     private internalCoreModule;
-    constructor(_applicationConfig?: ApplicationConfig);
+    constructor(_applicationConfig?: ApplicationConfig | undefined, _contextOptions?: NestApplicationContextOptions | undefined);
     get serializedGraph(): SerializedGraph;
     get applicationConfig(): ApplicationConfig | undefined;
     setHttpAdapter(httpAdapter: any): void;
@@ -41,7 +42,7 @@ export declare class NestContainer {
     addGlobalModule(module: Module): void;
     getModules(): ModulesContainer;
     getModuleCompiler(): ModuleCompiler;
-    getModuleByKey(moduleKey: string): Module;
+    getModuleByKey(moduleKey: string): Module | undefined;
     getInternalCoreModuleRef(): Module | undefined;
     addImport(relatedModule: Type<any> | DynamicModule, token: string): Promise<void>;
     addProvider(provider: Provider, token: string, enhancerSubtype?: EnhancerSubtype): string | symbol | Function;
@@ -49,7 +50,7 @@ export declare class NestContainer {
     addExportedProvider(provider: Type<any>, token: string): void;
     addController(controller: Type<any>, token: string): void;
     clear(): void;
-    replace(toReplace: any, options: any & {
+    replace(toReplace: any, options: {
         scope: any[] | null;
     }): void;
     bindGlobalScope(): void;
@@ -58,7 +59,7 @@ export declare class NestContainer {
     getDynamicMetadataByToken(token: string): Partial<DynamicModule>;
     getDynamicMetadataByToken<K extends Exclude<keyof DynamicModule, 'global' | 'module'>>(token: string, metadataKey: K): DynamicModule[K];
     registerCoreModuleRef(moduleRef: Module): void;
-    getModuleTokenFactory(): ModuleTokenFactory;
+    getModuleTokenFactory(): ModuleOpaqueKeyFactory;
     registerRequestProvider<T = any>(request: T, contextId: ContextId): void;
     private shouldInitOnPreview;
 }

package/injector/container.js

@@ -11,18 +11,26 @@ const compiler_1 = require("./compiler");
 const internal_core_module_1 = require("./internal-core-module/internal-core-module");
 const internal_providers_storage_1 = require("./internal-providers-storage");
 const module_1 = require("./module");
-const module_token_factory_1 = require("./module-token-factory");
 const modules_container_1 = require("./modules-container");
+const by_reference_module_opaque_key_factory_1 = require("./opaque-key-factory/by-reference-module-opaque-key-factory");
+const deep_hashed_module_opaque_key_factory_1 = require("./opaque-key-factory/deep-hashed-module-opaque-key-factory");
 class NestContainer {
-    constructor(_applicationConfig = undefined) {
+    constructor(_applicationConfig = undefined, _contextOptions = undefined) {
         this._applicationConfig = _applicationConfig;
+        this._contextOptions = _contextOptions;
         this.globalModules = new Set();
-        this.moduleTokenFactory = new module_token_factory_1.ModuleTokenFactory();
-        this.moduleCompiler = new compiler_1.ModuleCompiler(this.moduleTokenFactory);
         this.modules = new modules_container_1.ModulesContainer();
         this.dynamicModulesMetadata = new Map();
         this.internalProvidersStorage = new internal_providers_storage_1.InternalProvidersStorage();
         this._serializedGraph = new serialized_graph_1.SerializedGraph();
+        const moduleOpaqueKeyFactory = this._contextOptions?.moduleIdGeneratorAlgorithm === 'deep-hash'
+            ? new deep_hashed_module_opaque_key_factory_1.DeepHashedModuleOpaqueKeyFactory()
+            : new by_reference_module_opaque_key_factory_1.ByReferenceModuleOpaqueKeyFactory({
+                keyGenerationStrategy: this._contextOptions?.snapshot
+                    ? 'shallow'
+                    : 'random',
+            });
+        this.moduleCompiler = new compiler_1.ModuleCompiler(moduleOpaqueKeyFactory);
     }
     get serializedGraph() {
         return this._serializedGraph;
@@ -203,7 +211,7 @@ class NestContainer {
         this.modules[internal_core_module_1.InternalCoreModule.name] = moduleRef;
     }
     getModuleTokenFactory() {
-        return this.moduleTokenFactory;
+        return this.moduleCompiler.moduleOpaqueKeyFactory;
     }
     registerRequestProvider(request, contextId) {
         const wrapper = this.internalCoreModule.getProviderByKey(request_constants_1.REQUEST);

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() {