@nestjs/core 10.4.10 → 11.0.0-next.1

package/router/legacy-route-converter.d.ts

@@ -0,0 +1,13 @@
+export declare class LegacyRouteConverter {
+    private static readonly logger;
+    /**
+     * Convert legacy routes to the new format (syntax).
+     * path-to-regexp used by Express>=v5 and @fastify/middie>=v9 no longer support unnamed wildcards.
+     * This method attempts to convert the old syntax to the new one, and logs an error if it fails.
+     * @param route The route to convert.
+     * @returns The converted route, or the original route if it cannot be converted.
+     */
+    static tryConvert(route: string): string;
+    static printError(route: string): void;
+    static printWarning(route: string): void;
+}

package/router/legacy-route-converter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyRouteConverter = void 0;
+const common_1 = require("@nestjs/common");
+const UNSUPPORTED_PATH_MESSAGE = (text, route) => `Unsupported route path: "${route}". In previous versions, the symbols ?, *, and + were used to denote optional or repeating path parameters. The latest version of "path-to-regexp" now requires the use of named parameters. For example, instead of using a route like /users/* to capture all routes starting with "/users", you should use /users/*path. For more details, refer to the migration guide.`;
+class LegacyRouteConverter {
+    /**
+     * Convert legacy routes to the new format (syntax).
+     * path-to-regexp used by Express>=v5 and @fastify/middie>=v9 no longer support unnamed wildcards.
+     * This method attempts to convert the old syntax to the new one, and logs an error if it fails.
+     * @param route The route to convert.
+     * @returns The converted route, or the original route if it cannot be converted.
+     */
+    static tryConvert(route) {
+        // Normalize path to eliminate additional conditions.
+        const routeWithLeadingSlash = route.startsWith('/') ? route : `/${route}`;
+        const normalizedRoute = route.endsWith('/')
+            ? routeWithLeadingSlash
+            : `${routeWithLeadingSlash}/`;
+        if (normalizedRoute.endsWith('/(.*)/')) {
+            // Skip printing warning for the "all" wildcard.
+            if (normalizedRoute !== '/(.*)/') {
+                this.printWarning(route);
+            }
+            return route.replace('(.*)', '*path');
+        }
+        if (normalizedRoute.endsWith('/*/')) {
+            // Skip printing warning for the "all" wildcard.
+            if (normalizedRoute !== '/*/') {
+                this.printWarning(route);
+            }
+            return route.replace('*', '*path');
+        }
+        if (normalizedRoute.endsWith('/+/')) {
+            this.printWarning(route);
+            return route.replace('/+', '/*path');
+        }
+        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...');
+    }
+}
+exports.LegacyRouteConverter = LegacyRouteConverter;
+LegacyRouteConverter.logger = new common_1.Logger(LegacyRouteConverter.name);

package/router/request/request-providers.js

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

package/router/route-params-factory.d.ts

@@ -1,9 +1,9 @@
 import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
 import { IRouteParamsFactory } from './interfaces/route-params-factory.interface';
 export declare class RouteParamsFactory implements IRouteParamsFactory {
-    exchangeKeyForValue<TRequest extends Record<string, any> = any, TResponse = any, TResult = any>(key: RouteParamtypes | string, data: string | object | any, { req, res, next }: {
+    exchangeKeyForValue<TRequest extends Record<string, any> = any, TResponse = any, TResult = any>(key: RouteParamtypes | string, data: string, { req, res, next }: {
         req: TRequest;
         res: TResponse;
         next: Function;
-    }): TResult;
+    }): TResult | null;
 }

package/router/route-params-factory.js

@@ -18,6 +18,7 @@ class RouteParamsFactory {
             case route_paramtypes_enum_1.RouteParamtypes.PARAM:
                 return data ? req.params[data] : req.params;
             case route_paramtypes_enum_1.RouteParamtypes.HOST:
+                /* eslint-disable-next-line no-case-declarations */
                 const hosts = req.hosts || {};
                 return data ? hosts[data] : hosts;
             case route_paramtypes_enum_1.RouteParamtypes.QUERY:

package/router/route-path-factory.d.ts

@@ -6,7 +6,7 @@ export declare class RoutePathFactory {
     private readonly applicationConfig;
     constructor(applicationConfig: ApplicationConfig);
     create(metadata: RoutePathMetadata, requestMethod?: RequestMethod): string[];
-    getVersion(metadata: RoutePathMetadata): VersionValue;
+    getVersion(metadata: RoutePathMetadata): VersionValue | undefined;
     getVersionPrefix(versioningOptions: VersioningOptions): string;
     appendToAllIfDefined(paths: string[], fragmentToAppend: string | string[] | undefined): string[];
     isExcludedFromGlobalPrefix(path: string, requestMethod?: RequestMethod, versionOrVersions?: VersionValue, versioningOptions?: VersioningOptions): boolean;

package/router/router-exception-filters.d.ts

@@ -9,6 +9,6 @@ export declare class RouterExceptionFilters extends BaseExceptionFilterContext {
     private readonly config;
     private readonly applicationRef;
     constructor(container: NestContainer, config: ApplicationConfig, applicationRef: HttpServer);
-    create(instance: Controller, callback: RouterProxyCallback, moduleKey: string, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): ExceptionsHandler;
+    create(instance: Controller, callback: RouterProxyCallback, moduleKey: string | undefined, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): ExceptionsHandler;
     getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
 }

package/router/router-exception-filters.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouterExceptionFilters = 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 base_exception_filter_context_1 = require("../exceptions/base-exception-filter-context");
 const exceptions_handler_1 = require("../exceptions/exceptions-handler");
 const constants_2 = require("../injector/constants");
-const iterare_1 = require("iterare");
 class RouterExceptionFilters extends base_exception_filter_context_1.BaseExceptionFilterContext {
     constructor(container, config, applicationRef) {
         super(container);

package/router/router-execution-context.d.ts

@@ -45,10 +45,10 @@ export declare class RouterExecutionContext {
         data: unknown;
     }, pipes: PipeTransform[]): Promise<unknown>;
     isPipeable(type: number | string): boolean;
-    createGuardsFn<TContext extends string = ContextType>(guards: CanActivate[], instance: Controller, callback: (...args: any[]) => any, contextType?: TContext): (args: any[]) => Promise<void> | null;
+    createGuardsFn<TContext extends string = ContextType>(guards: CanActivate[], instance: Controller, callback: (...args: any[]) => any, contextType?: TContext): ((args: any[]) => Promise<void>) | null;
     createPipesFn(pipes: PipeTransform[], paramsOptions: (ParamProperties & {
         metatype?: any;
-    })[]): <TRequest, TResponse>(args: any[], req: TRequest, res: TResponse, next: Function) => Promise<void>;
+    })[]): (<TRequest, TResponse>(args: any[], req: TRequest, res: TResponse, next: Function) => Promise<void>) | null;
     createHandleResponseFn(callback: (...args: unknown[]) => unknown, isResponseHandled: boolean, redirectResponse?: RedirectResponse, httpStatusCode?: number): HandleResponseFn;
     private isResponseHandled;
 }

package/router/router-execution-context.js

@@ -108,7 +108,7 @@ class RouterExecutionContext {
             }
             const numericType = Number(type);
             const extractValue = (req, res, next) => this.paramsFactory.exchangeKeyForValue(numericType, data, {
-                req,
+                req: req,
                 res,
                 next,
             });

package/router/router-explorer.js

@@ -6,7 +6,7 @@ const enums_1 = require("@nestjs/common/enums");
 const exceptions_1 = require("@nestjs/common/exceptions");
 const logger_service_1 = require("@nestjs/common/services/logger.service");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const pathToRegexp = require("path-to-regexp");
+const path_to_regexp_1 = require("path-to-regexp");
 const unknown_request_mapping_exception_1 = require("../errors/exceptions/unknown-request-mapping.exception");
 const guards_1 = require("../guards");
 const context_id_factory_1 = require("../helpers/context-id-factory");
@@ -16,6 +16,7 @@ const router_method_factory_1 = require("../helpers/router-method-factory");
 const constants_2 = require("../injector/constants");
 const interceptors_1 = require("../interceptors");
 const pipes_1 = require("../pipes");
+const legacy_route_converter_1 = require("./legacy-route-converter");
 const paths_explorer_1 = require("./paths-explorer");
 const request_constants_1 = require("./request/request-constants");
 const route_params_factory_1 = require("./route-params-factory");
@@ -102,7 +103,16 @@ class RouterExplorer {
                     },
                 };
                 this.copyMetadataToCallback(targetCallback, routeHandler);
-                routerMethodRef(path, routeHandler);
+                try {
+                    const convertedPath = legacy_route_converter_1.LegacyRouteConverter.tryConvert(path);
+                    routerMethodRef(convertedPath, routeHandler);
+                }
+                catch (e) {
+                    if (e instanceof TypeError) {
+                        legacy_route_converter_1.LegacyRouteConverter.printError(path);
+                    }
+                    throw e;
+                }
                 this.graphInspector.insertEntrypointDefinition(entrypointDefinition, instanceWrapper.id);
             });
             const pathsToLog = this.routePathFactory.create({
@@ -127,9 +137,18 @@ class RouterExplorer {
         const httpAdapterRef = this.container.getHttpAdapterRef();
         const hosts = Array.isArray(host) ? host : [host];
         const hostRegExps = hosts.map((host) => {
-            const keys = [];
-            const regexp = pathToRegexp(host, keys);
-            return { regexp, keys };
+            if (typeof host === 'string') {
+                try {
+                    return (0, path_to_regexp_1.pathToRegexp)(host);
+                }
+                catch (e) {
+                    if (e instanceof TypeError) {
+                        this.logger.error(`Unsupported host "${host}" syntax. In past releases, ?, *, and + were used to denote optional or repeating path parameters. The latest version of "path-to-regexp" now requires the use of named parameters. For example, instead of using a route like /users/* to capture all routes starting with "/users", you should use /users/*path. Please see the migration guide for more information.`);
+                    }
+                    throw e;
+                }
+            }
+            return { regexp: host, keys: [] };
         });
         const unsupportedFilteringErrorMessage = Array.isArray(host)
             ? `HTTP adapter does not support filtering on hosts: ["${host.join('", "')}"]`

package/router/router-proxy.d.ts

@@ -1,6 +1,6 @@
 import { ExceptionsHandler } from '../exceptions/exceptions-handler';
-export type RouterProxyCallback = <TRequest, TResponse>(req?: TRequest, res?: TResponse, next?: () => void) => void;
+export type RouterProxyCallback = <TRequest, TResponse>(req: TRequest, res: TResponse, next: () => void) => void | Promise<void>;
 export declare class RouterProxy {
-    createProxy(targetCallback: RouterProxyCallback, exceptionsHandler: ExceptionsHandler): <TRequest, TResponse>(req: TRequest, res: TResponse, next: () => void) => Promise<TResponse>;
-    createExceptionLayerProxy(targetCallback: <TError, TRequest, TResponse>(err: TError, req: TRequest, res: TResponse, next: () => void) => void, exceptionsHandler: ExceptionsHandler): <TError, TRequest, TResponse>(err: TError, req: TRequest, res: TResponse, next: () => void) => Promise<TResponse>;
+    createProxy(targetCallback: RouterProxyCallback, exceptionsHandler: ExceptionsHandler): <TRequest, TResponse>(req: TRequest, res: TResponse, next: () => void) => Promise<TResponse | undefined>;
+    createExceptionLayerProxy(targetCallback: <TError, TRequest, TResponse>(err: TError, req: TRequest, res: TResponse, next: () => void) => void | Promise<void>, exceptionsHandler: ExceptionsHandler): <TError, TRequest, TResponse>(err: TError, req: TRequest, res: TResponse, next: () => void) => Promise<TResponse | undefined>;
 }

package/router/sse-stream.js

@@ -49,7 +49,7 @@ class SseStream extends stream_1.Transform {
                 // NGINX support https://www.nginx.com/resources/wiki/start/topics/examples/x-accel/#x-accel-buffering
                 'X-Accel-Buffering': 'no',
             });
-            destination.flushHeaders();
+            destination.flushHeaders?.();
         }
         destination.write('\n');
         return super.pipe(destination, options);

package/router/utils/flatten-route-paths.util.d.ts

@@ -1,2 +1,6 @@
+import { Type } from '@nestjs/common';
 import { Routes } from '../interfaces/routes.interface';
-export declare function flattenRoutePaths(routes: Routes): any[];
+export declare function flattenRoutePaths(routes: Routes): {
+    module: Type;
+    path: string;
+}[];

package/scanner.d.ts

@@ -46,8 +46,8 @@ export declare class DependenciesScanner {
     calculateModulesDistance(): void;
     insertImport(related: any, token: string, context: string): Promise<void>;
     isCustomProvider(provider: Provider): provider is ClassProvider | ValueProvider | FactoryProvider | ExistingProvider;
-    insertProvider(provider: Provider, token: string): string | symbol | Function | InstanceWrapper<unknown>;
-    insertInjectable(injectable: Type<Injectable> | object, token: string, host: Type<Injectable>, subtype: EnhancerSubtype, methodKey?: string): InstanceWrapper<any>;
+    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;
     insertController(controller: Type<Controller>, token: string): void;
     private insertOrOverrideModule;

package/scanner.js

@@ -29,9 +29,9 @@ class DependenciesScanner {
             overrides: options?.overrides,
         });
         await this.scanModulesForDependencies();
-        this.calculateModulesDistance();
         this.addScopedEnhancersMetadata();
         this.container.bindGlobalScope();
+        this.calculateModulesDistance();
     }
     async scanForModules({ moduleDefinition, lazy, scope = [], ctxRegistry = [], overrides = [], }) {
         const { moduleRef: moduleInstance, inserted: moduleInserted } = (await this.insertOrOverrideModule(moduleDefinition, overrides, scope)) ??
@@ -198,19 +198,19 @@ class DependenciesScanner {
         const modulesGenerator = this.container.getModules().values();
         // Skip "InternalCoreModule" from calculating distance
         modulesGenerator.next();
-        const modulesStack = [];
-        const calculateDistance = (moduleRef, distance = 1) => {
-            if (!moduleRef || modulesStack.includes(moduleRef)) {
+        const calculateDistance = (moduleRef, distance = 1, modulesStack = []) => {
+            const localModulesStack = [...modulesStack];
+            if (!moduleRef || localModulesStack.includes(moduleRef)) {
                 return;
             }
-            modulesStack.push(moduleRef);
+            localModulesStack.push(moduleRef);
             const moduleImports = moduleRef.imports;
             moduleImports.forEach(importedModuleRef => {
                 if (importedModuleRef) {
                     if (distance > importedModuleRef.distance) {
                         importedModuleRef.distance = distance;
                     }
-                    calculateDistance(importedModuleRef, distance + 1);
+                    calculateDistance(importedModuleRef, distance + 1, localModulesStack);
                 }
             });
         };

package/services/reflector.service.d.ts

@@ -66,7 +66,7 @@ export declare class Reflector {
      * @param targets context (decorated objects) to retrieve metadata from
      *
      */
-    getAll<T extends ReflectableDecorator<any>>(decorator: T, targets: (Type<any> | Function)[]): T extends ReflectableDecorator<infer R> ? R extends Array<any> ? R : R[] : unknown;
+    getAll<TParam = any, TTransformed = TParam>(decorator: ReflectableDecorator<TParam, TTransformed>, targets: (Type<any> | Function)[]): TTransformed extends Array<any> ? TTransformed : TTransformed[];
     /**
      * Retrieve metadata for a specified key for a specified set of targets.
      *
@@ -82,7 +82,7 @@ export declare class Reflector {
      * @param targets context (decorated objects) to retrieve metadata from
      *
      */
-    getAllAndMerge<T extends ReflectableDecorator<any>>(decorator: T, targets: (Type<any> | Function)[]): T extends ReflectableDecorator<infer R> ? R : unknown;
+    getAllAndMerge<TParam = any, TTransformed = TParam>(decorator: ReflectableDecorator<TParam, TTransformed>, targets: (Type<any> | Function)[]): TTransformed extends Array<any> ? TTransformed : TTransformed extends object ? TTransformed : TTransformed[];
     /**
      * Retrieve metadata for a specified key for a specified set of targets and merge results.
      *
@@ -98,7 +98,7 @@ export declare class Reflector {
      * @param targets context (decorated objects) to retrieve metadata from
      *
      */
-    getAllAndOverride<T extends ReflectableDecorator<any>>(decorator: T, targets: (Type<any> | Function)[]): T extends ReflectableDecorator<infer R> ? R : unknown;
+    getAllAndOverride<TParam = any, TTransformed = TParam>(decorator: ReflectableDecorator<TParam, TTransformed>, targets: (Type<any> | Function)[]): TTransformed;
     /**
      * Retrieve metadata for a specified key for a specified set of targets and return a first not undefined value.
      *

package/services/reflector.service.js

@@ -60,6 +60,13 @@ class Reflector {
         if ((0, shared_utils_1.isEmpty)(metadataCollection)) {
             return metadataCollection;
         }
+        if (metadataCollection.length === 1) {
+            const value = metadataCollection[0];
+            if ((0, shared_utils_1.isObject)(value)) {
+                return value;
+            }
+            return metadataCollection;
+        }
         return metadataCollection.reduce((a, b) => {
             if (Array.isArray(a)) {
                 return a.concat(b);