@nestjs/core 11.0.0-next.4 → 11.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2024 Kamil Mysliwiec <https://kamilmysliwiec.com>
+Copyright (c) 2017-2025 Kamil Mysliwiec <https://kamilmysliwiec.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/adapters/http-adapter.d.ts

@@ -1,14 +1,13 @@
 import { HttpServer, RequestMethod, VersioningOptions } from '@nestjs/common';
 import { RequestHandler, VersionValue } from '@nestjs/common/interfaces';
-import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface';
 import { NestApplicationOptions } from '@nestjs/common/interfaces/nest-application-options.interface';
 /**
  * @publicApi
  */
 export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any, TResponse = any> implements HttpServer<TRequest, TResponse> {
-    protected instance?: any;
+    protected instance?: any | undefined;
     protected httpServer: TServer;
-    constructor(instance?: any);
+    constructor(instance?: any | undefined);
     init(): Promise<void>;
     use(...args: any[]): any;
     get(handler: RequestHandler): any;
@@ -67,7 +66,7 @@ export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any,
     abstract isHeadersSent(response: any): any;
     abstract setHeader(response: any, name: string, value: string): any;
     abstract registerParserMiddleware(prefix?: string, rawBody?: boolean): any;
-    abstract enableCors(options: CorsOptions | CorsOptionsDelegate<TRequest>, prefix?: string): any;
+    abstract enableCors(options?: any, prefix?: string): any;
     abstract createMiddlewareFactory(requestMethod: RequestMethod): ((path: string, callback: Function) => any) | Promise<(path: string, callback: Function) => any>;
     abstract getType(): string;
     abstract applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): (req: TRequest, res: TResponse, next: () => void) => Function;

package/errors/messages.d.ts

@@ -7,7 +7,7 @@ export declare const UNDEFINED_FORWARDREF_MESSAGE: (scope: Type<any>[]) => strin
 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) | undefined, 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/helpers/router-method-factory.d.ts

@@ -1,5 +1,23 @@
 import { HttpServer } from '@nestjs/common';
 import { RequestMethod } from '@nestjs/common/enums/request-method.enum';
+export declare const REQUEST_METHOD_MAP: {
+    readonly 0: "get";
+    readonly 1: "post";
+    readonly 2: "put";
+    readonly 3: "delete";
+    readonly 4: "patch";
+    readonly 5: "all";
+    readonly 6: "options";
+    readonly 7: "head";
+    readonly 8: "search";
+    readonly 9: "propfind";
+    readonly 10: "proppatch";
+    readonly 11: "mkcol";
+    readonly 12: "copy";
+    readonly 13: "move";
+    readonly 14: "lock";
+    readonly 15: "unlock";
+};
 export declare class RouterMethodFactory {
     get(target: HttpServer, requestMethod: RequestMethod): Function;
 }

package/helpers/router-method-factory.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterMethodFactory = void 0;
+exports.RouterMethodFactory = exports.REQUEST_METHOD_MAP = void 0;
 const request_method_enum_1 = require("@nestjs/common/enums/request-method.enum");
-const REQUEST_METHOD_MAP = {
+exports.REQUEST_METHOD_MAP = {
     [request_method_enum_1.RequestMethod.GET]: 'get',
     [request_method_enum_1.RequestMethod.POST]: 'post',
     [request_method_enum_1.RequestMethod.PUT]: 'put',
@@ -22,7 +22,7 @@ const REQUEST_METHOD_MAP = {
 };
 class RouterMethodFactory {
     get(target, requestMethod) {
-        const methodName = REQUEST_METHOD_MAP[requestMethod];
+        const methodName = exports.REQUEST_METHOD_MAP[requestMethod];
         const method = target[methodName];
         if (!method) {
             return target.use;

package/index.js

@@ -4,7 +4,7 @@ exports.NestFactory = exports.APP_PIPE = exports.APP_INTERCEPTOR = exports.APP_G
 const tslib_1 = require("tslib");
 /*
  * Nest @core
- * Copyright(c) 2017 - 2023 Kamil Mysliwiec
+ * Copyright(c) 2017 - 2025 Kamil Mysliwiec
  * https://nestjs.com
  * MIT Licensed
  */

package/injector/container.d.ts

@@ -47,7 +47,7 @@ export declare class NestContainer {
     addImport(relatedModule: Type<any> | DynamicModule, token: string): Promise<void>;
     addProvider(provider: Provider, token: string, enhancerSubtype?: EnhancerSubtype): string | symbol | Function;
     addInjectable(injectable: Provider, token: string, enhancerSubtype: EnhancerSubtype, host?: Type<Injectable>): string | symbol | Function | import("./instance-wrapper").InstanceWrapper<unknown>;
-    addExportedProvider(provider: Type<any>, token: string): void;
+    addExportedProviderOrModule(toExport: Type<any> | DynamicModule, token: string): void;
     addController(controller: Type<any>, token: string): void;
     clear(): void;
     replace(toReplace: any, options: {

package/injector/container.js

@@ -171,12 +171,12 @@ class NestContainer {
         const moduleRef = this.modules.get(token);
         return moduleRef.addInjectable(injectable, enhancerSubtype, host);
     }
-    addExportedProvider(provider, token) {
+    addExportedProviderOrModule(toExport, token) {
         if (!this.modules.has(token)) {
             throw new exceptions_1.UnknownModuleException();
         }
         const moduleRef = this.modules.get(token);
-        moduleRef.addExportedProvider(provider);
+        moduleRef.addExportedProviderOrModule(toExport);
     }
     addController(controller, token) {
         if (!this.modules.has(token)) {

package/injector/module-token-factory.d.ts

@@ -0,0 +1,14 @@
+import { DynamicModule } from '@nestjs/common';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+export declare class ModuleTokenFactory {
+    private readonly moduleTokenCache;
+    private readonly moduleIdsCache;
+    private readonly logger;
+    create(metatype: Type<unknown>, dynamicModuleMetadata?: Partial<DynamicModule> | undefined): string;
+    getStaticModuleToken(moduleId: string, moduleName: string): string;
+    getStringifiedOpaqueToken(opaqueToken: object | undefined): string;
+    getModuleId(metatype: Type<unknown>): string;
+    getModuleName(metatype: Type<any>): string;
+    private hashString;
+    private replacer;
+}

package/injector/module-token-factory.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleTokenFactory = void 0;
+const common_1 = require("@nestjs/common");
+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 perf_hooks_1 = require("perf_hooks");
+const CLASS_STR = 'class ';
+const CLASS_STR_LEN = CLASS_STR.length;
+class ModuleTokenFactory {
+    constructor() {
+        this.moduleTokenCache = new Map();
+        this.moduleIdsCache = new WeakMap();
+        this.logger = new common_1.Logger(ModuleTokenFactory.name, {
+            timestamp: true,
+        });
+    }
+    create(metatype, dynamicModuleMetadata) {
+        const moduleId = this.getModuleId(metatype);
+        if (!dynamicModuleMetadata) {
+            return this.getStaticModuleToken(moduleId, this.getModuleName(metatype));
+        }
+        const opaqueToken = {
+            id: moduleId,
+            module: this.getModuleName(metatype),
+            dynamic: dynamicModuleMetadata,
+        };
+        const start = perf_hooks_1.performance.now();
+        const opaqueTokenString = this.getStringifiedOpaqueToken(opaqueToken);
+        const timeSpentInMs = perf_hooks_1.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. More details: https://github.com/nestjs/nest/issues/12738`);
+        }
+        return this.hashString(opaqueTokenString);
+    }
+    getStaticModuleToken(moduleId, moduleName) {
+        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;
+    }
+    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.ModuleTokenFactory = ModuleTokenFactory;

package/injector/module.d.ts

@@ -56,16 +56,12 @@ 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> | undefined;
+    addExportedProviderOrModule(toExport: 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;
     addImport(moduleRef: Module): void;
-    /**
-     * @deprecated
-     */
-    addRelatedModule(module: Module): void;
     replace(toReplace: InjectionToken, options: any): void;
     hasProvider(token: InjectionToken): boolean;
     hasInjectable(token: InjectionToken): boolean;

package/injector/module.js

@@ -277,19 +277,19 @@ class Module {
             subtype: enhancerSubtype,
         }));
     }
-    addExportedProvider(provider) {
+    addExportedProviderOrModule(toExport) {
         const addExportedUnit = (token) => this._exports.add(this.validateExportedProvider(token));
-        if (this.isCustomProvider(provider)) {
-            return this.addCustomExportedProvider(provider);
+        if (this.isCustomProvider(toExport)) {
+            return this.addCustomExportedProvider(toExport);
         }
-        else if ((0, shared_utils_1.isString)(provider) || (0, shared_utils_1.isSymbol)(provider)) {
-            return addExportedUnit(provider);
+        else if ((0, shared_utils_1.isString)(toExport) || (0, shared_utils_1.isSymbol)(toExport)) {
+            return addExportedUnit(toExport);
         }
-        else if (this.isDynamicModule(provider)) {
-            const { module: moduleClassRef } = provider;
+        else if (this.isDynamicModule(toExport)) {
+            const { module: moduleClassRef } = toExport;
             return addExportedUnit(moduleClassRef);
         }
-        addExportedUnit(provider);
+        addExportedUnit(toExport);
     }
     addCustomExportedProvider(provider) {
         const provide = provider.provide;
@@ -338,12 +338,6 @@ class Module {
     addImport(moduleRef) {
         this._imports.add(moduleRef);
     }
-    /**
-     * @deprecated
-     */
-    addRelatedModule(module) {
-        this._imports.add(module);
-    }
     replace(toReplace, options) {
         if (options.isProvider && this.hasProvider(toReplace)) {
             const originalProvider = this._providers.get(toReplace);

package/nest-application.d.ts

@@ -1,6 +1,5 @@
 import { CanActivate, ExceptionFilter, HttpServer, INestApplication, INestMicroservice, NestHybridApplicationOptions, NestInterceptor, PipeTransform, VersioningOptions, WebSocketAdapter } from '@nestjs/common';
 import { GlobalPrefixOptions, NestApplicationOptions } from '@nestjs/common/interfaces';
-import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface';
 import { Logger } from '@nestjs/common/services/logger.service';
 import { AbstractHttpAdapter } from './adapters';
 import { ApplicationConfig } from './application-config';
@@ -42,7 +41,7 @@ export declare class NestApplication extends NestApplicationContext<NestApplicat
     startAllMicroservices(): Promise<this>;
     use(...args: [any, any?]): this;
     useBodyParser(...args: [any, any?]): this;
-    enableCors(options?: CorsOptions | CorsOptionsDelegate<any>): void;
+    enableCors(options?: any): void;
     enableVersioning(options?: VersioningOptions): this;
     listen(port: number | string): Promise<any>;
     listen(port: number | string, hostname: string): Promise<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "11.0.0-next.4",
+  "version": "11.0.1",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -9,6 +9,9 @@
     "type": "opencollective",
     "url": "https://opencollective.com/nest"
   },
+  "engines": {
+    "node": ">= 20"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/nestjs/nest.git",
@@ -28,21 +31,21 @@
     }
   },
   "dependencies": {
-    "@nuxtjs/opencollective": "0.3.2",
+    "@nuxt/opencollective": "0.4.1",
     "fast-safe-stringify": "2.1.1",
     "iterare": "1.2.1",
     "path-to-regexp": "8.2.0",
-    "tslib": "2.7.0",
+    "tslib": "2.8.1",
     "uid": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "^11.0.0-next.4"
+    "@nestjs/common": "11.0.1"
   },
   "peerDependencies": {
-    "@nestjs/common": "^10.0.0",
-    "@nestjs/microservices": "^10.0.0",
-    "@nestjs/platform-express": "^10.0.0",
-    "@nestjs/websockets": "^10.0.0",
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/microservices": "^11.0.0",
+    "@nestjs/platform-express": "^11.0.0",
+    "@nestjs/websockets": "^11.0.0",
     "reflect-metadata": "^0.1.12 || ^0.2.0",
     "rxjs": "^7.1.0"
   },

package/router/legacy-route-converter.js

@@ -12,7 +12,7 @@ class LegacyRouteConverter {
      * @returns The converted route, or the original route if it cannot be converted.
      */
     static tryConvert(route) {
-        // Normalize path to eliminate additional conditions.
+        // Normalize path to eliminate additional if statements.
         const routeWithLeadingSlash = route.startsWith('/') ? route : `/${route}`;
         const normalizedRoute = route.endsWith('/')
             ? routeWithLeadingSlash
@@ -35,13 +35,21 @@ class LegacyRouteConverter {
             this.printWarning(route);
             return route.replace('/+', '/*path');
         }
+        // When route includes any wildcard segments in the middle.
+        if (normalizedRoute.includes('/*/')) {
+            this.printWarning(route);
+            // Replace each /*/ segment with a named parameter using different name for each segment.
+            return route.replaceAll('/*/', (match, offset) => {
+                return `/*path${offset}/`;
+            });
+        }
         return route;
     }
     static printError(route) {
         this.logger.error(UNSUPPORTED_PATH_MESSAGE `${route}`);
     }
     static printWarning(route) {
-        this.logger.warn(UNSUPPORTED_PATH_MESSAGE `${route}` + ' Attempting to convert...');
+        this.logger.warn(UNSUPPORTED_PATH_MESSAGE `${route}` + ' Attempting to auto-convert...');
     }
 }
 exports.LegacyRouteConverter = LegacyRouteConverter;

package/scanner.d.ts

@@ -48,7 +48,7 @@ export declare class DependenciesScanner {
     isCustomProvider(provider: Provider): provider is ClassProvider | ValueProvider | FactoryProvider | ExistingProvider;
     insertProvider(provider: Provider, token: string): string | symbol | Function | InstanceWrapper<unknown> | undefined;
     insertInjectable(injectable: Type<Injectable> | object, token: string, host: Type<Injectable>, subtype: EnhancerSubtype, methodKey?: string): InstanceWrapper<any> | undefined;
-    insertExportedProvider(exportedProvider: Type<Injectable> | ForwardReference, token: string): void;
+    insertExportedProviderOrModule(toExport: ForwardReference | DynamicModule | Type<unknown>, token: string): void;
     insertController(controller: Type<Controller>, token: string): void;
     private insertOrOverrideModule;
     private getOverrideModuleByModule;

package/scanner.js

@@ -148,7 +148,7 @@ class DependenciesScanner {
             ...this.reflectMetadata(constants_1.MODULE_METADATA.EXPORTS, module),
             ...this.container.getDynamicMetadataByToken(token, constants_1.MODULE_METADATA.EXPORTS),
         ];
-        exports.forEach(exportedProvider => this.insertExportedProvider(exportedProvider, token));
+        exports.forEach(exportedProvider => this.insertExportedProviderOrModule(exportedProvider, token));
     }
     reflectInjectables(component, token, metadataKey) {
         const controllerInjectables = this.reflectMetadata(metadataKey, component);
@@ -291,13 +291,11 @@ class DependenciesScanner {
             });
         }
     }
-    insertExportedProvider(
-    // TODO: improve the type definition below because it doesn't reflects the real usage of this method
-    exportedProvider, token) {
-        const fulfilledProvider = this.isForwardReference(exportedProvider)
-            ? exportedProvider.forwardRef()
-            : exportedProvider;
-        this.container.addExportedProvider(fulfilledProvider, token);
+    insertExportedProviderOrModule(toExport, token) {
+        const fulfilledProvider = this.isForwardReference(toExport)
+            ? toExport.forwardRef()
+            : toExport;
+        this.container.addExportedProviderOrModule(fulfilledProvider, token);
     }
     insertController(controller, token) {
         this.container.addController(controller, token);