@nestjs/core 10.3.1 → 10.3.3

package/adapters/http-adapter.d.ts

@@ -25,8 +25,8 @@ export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any,
     patch(path: any, handler: RequestHandler): any;
     all(handler: RequestHandler): any;
     all(path: any, handler: RequestHandler): any;
-    search(port: string | number, callback?: () => void): any;
-    search(port: string | number, hostname: string, callback?: () => void): any;
+    search(handler: RequestHandler): any;
+    search(path: any, handler: RequestHandler): any;
     options(handler: RequestHandler): any;
     options(path: any, handler: RequestHandler): any;
     listen(port: string | number, callback?: () => void): any;
@@ -50,7 +50,9 @@ export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any,
     abstract setErrorHandler(handler: Function, prefix?: string): any;
     abstract setNotFoundHandler(handler: Function, prefix?: string): any;
     abstract isHeadersSent(response: any): any;
+    abstract getHeader?(response: any, name: string): any;
     abstract setHeader(response: any, name: string, value: string): any;
+    abstract appendHeader?(response: any, name: string, value: string): any;
     abstract registerParserMiddleware(prefix?: string, rawBody?: boolean): any;
     abstract enableCors(options: CorsOptions | CorsOptionsDelegate<TRequest>, prefix?: string): any;
     abstract createMiddlewareFactory(requestMethod: RequestMethod): ((path: string, callback: Function) => any) | Promise<(path: string, callback: Function) => any>;

package/adapters/http-adapter.js

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

package/helpers/router-method-factory.js

@@ -2,29 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouterMethodFactory = void 0;
 const request_method_enum_1 = require("@nestjs/common/enums/request-method.enum");
+const REQUEST_METHOD_MAP = {
+    [request_method_enum_1.RequestMethod.GET]: 'get',
+    [request_method_enum_1.RequestMethod.POST]: 'post',
+    [request_method_enum_1.RequestMethod.PUT]: 'put',
+    [request_method_enum_1.RequestMethod.DELETE]: 'delete',
+    [request_method_enum_1.RequestMethod.PATCH]: 'patch',
+    [request_method_enum_1.RequestMethod.ALL]: 'all',
+    [request_method_enum_1.RequestMethod.OPTIONS]: 'options',
+    [request_method_enum_1.RequestMethod.HEAD]: 'head',
+    [request_method_enum_1.RequestMethod.SEARCH]: 'search',
+};
 class RouterMethodFactory {
     get(target, requestMethod) {
-        switch (requestMethod) {
-            case request_method_enum_1.RequestMethod.POST:
-                return target.post;
-            case request_method_enum_1.RequestMethod.ALL:
-                return target.all;
-            case request_method_enum_1.RequestMethod.DELETE:
-                return target.delete;
-            case request_method_enum_1.RequestMethod.PUT:
-                return target.put;
-            case request_method_enum_1.RequestMethod.PATCH:
-                return target.patch;
-            case request_method_enum_1.RequestMethod.OPTIONS:
-                return target.options;
-            case request_method_enum_1.RequestMethod.HEAD:
-                return target.head;
-            case request_method_enum_1.RequestMethod.GET:
-                return target.get;
-            default: {
-                return target.use;
-            }
+        const methodName = REQUEST_METHOD_MAP[requestMethod];
+        const method = target[methodName];
+        if (!method) {
+            return target.use;
         }
+        return method;
     }
 }
 exports.RouterMethodFactory = RouterMethodFactory;

package/middleware/builder.js

@@ -34,10 +34,15 @@ MiddlewareBuilder.ConfigProxy = class {
         return this.excludedRoutes;
     }
     exclude(...routes) {
-        this.excludedRoutes = this.getRoutesFlatList(routes).map(route => ({
-            ...route,
-            path: this.routeInfoPathExtractor.extractPathFrom(route),
-        }));
+        this.excludedRoutes = this.getRoutesFlatList(routes).reduce((excludedRoutes, route) => {
+            for (const routePath of this.routeInfoPathExtractor.extractPathFrom(route)) {
+                excludedRoutes.push({
+                    ...route,
+                    path: routePath,
+                });
+            }
+            return excludedRoutes;
+        }, []);
         return this;
     }
     forRoutes(...routes) {

package/middleware/route-info-path-extractor.d.ts

@@ -2,14 +2,14 @@ import { RouteInfo } from '@nestjs/common/interfaces';
 import { ApplicationConfig } from '../application-config';
 export declare class RouteInfoPathExtractor {
     private readonly applicationConfig;
-    private routePathFactory;
+    private readonly routePathFactory;
     private readonly prefixPath;
     private readonly excludedGlobalPrefixRoutes;
     private readonly versioningConfig?;
     constructor(applicationConfig: ApplicationConfig);
     extractPathsFrom({ path, method, version }: RouteInfo): string[];
-    extractPathFrom(route: RouteInfo): string;
+    extractPathFrom(route: RouteInfo): string[];
     private isAWildcard;
-    private extractNonWildcardPathFrom;
+    private extractNonWildcardPathsFrom;
     private extractVersionPathFrom;
 }

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

@@ -15,39 +15,51 @@ class RouteInfoPathExtractor {
         this.versioningConfig = this.applicationConfig.getVersioning();
     }
     extractPathsFrom({ path, method, version }) {
-        const versionPath = this.extractVersionPathFrom(version);
+        const versionPaths = this.extractVersionPathFrom(version);
         if (this.isAWildcard(path)) {
+            const entries = versionPaths.length > 0
+                ? versionPaths.map(versionPath => this.prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path))
+                : [this.prefixPath + (0, shared_utils_1.addLeadingSlash)(path)];
             return Array.isArray(this.excludedGlobalPrefixRoutes)
                 ? [
-                    this.prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path),
-                    ...this.excludedGlobalPrefixRoutes.map(route => versionPath + (0, shared_utils_1.addLeadingSlash)(route.path)),
+                    ...entries,
+                    ...this.excludedGlobalPrefixRoutes.map(route => versionPaths + (0, shared_utils_1.addLeadingSlash)(route.path)),
                 ]
-                : [this.prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path)];
+                : entries;
         }
-        return [this.extractNonWildcardPathFrom({ path, method, version })];
+        return this.extractNonWildcardPathsFrom({ path, method, version });
     }
     extractPathFrom(route) {
         if (this.isAWildcard(route.path) && !route.version) {
-            return (0, shared_utils_1.addLeadingSlash)(route.path);
+            return [(0, shared_utils_1.addLeadingSlash)(route.path)];
         }
-        return this.extractNonWildcardPathFrom(route);
+        return this.extractNonWildcardPathsFrom(route);
     }
     isAWildcard(path) {
         return ['*', '/*', '/*/', '(.*)', '/(.*)'].includes(path);
     }
-    extractNonWildcardPathFrom({ path, method, version, }) {
-        const versionPath = this.extractVersionPathFrom(version);
+    extractNonWildcardPathsFrom({ path, method, version, }) {
+        const versionPaths = this.extractVersionPathFrom(version);
         if (Array.isArray(this.excludedGlobalPrefixRoutes) &&
             (0, utils_1.isRouteExcluded)(this.excludedGlobalPrefixRoutes, path, method)) {
-            return versionPath + (0, shared_utils_1.addLeadingSlash)(path);
+            if (!versionPaths.length) {
+                return [(0, shared_utils_1.addLeadingSlash)(path)];
+            }
+            return versionPaths.map(versionPath => versionPath + (0, shared_utils_1.addLeadingSlash)(path));
         }
-        return this.prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path);
+        if (!versionPaths.length) {
+            return [this.prefixPath + (0, shared_utils_1.addLeadingSlash)(path)];
+        }
+        return versionPaths.map(versionPath => this.prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path));
     }
-    extractVersionPathFrom(version) {
-        if (!version || this.versioningConfig?.type !== common_1.VersioningType.URI)
-            return '';
+    extractVersionPathFrom(versionValue) {
+        if (!versionValue || this.versioningConfig?.type !== common_1.VersioningType.URI)
+            return [];
         const versionPrefix = this.routePathFactory.getVersionPrefix(this.versioningConfig);
-        return (0, shared_utils_1.addLeadingSlash)(versionPrefix + version.toString());
+        if (Array.isArray(versionValue)) {
+            return versionValue.map(version => (0, shared_utils_1.addLeadingSlash)(versionPrefix + version.toString()));
+        }
+        return [(0, shared_utils_1.addLeadingSlash)(versionPrefix + versionValue.toString())];
     }
 }
 exports.RouteInfoPathExtractor = RouteInfoPathExtractor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "10.3.1",
+  "version": "10.3.3",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -36,14 +36,14 @@
     "uid": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "10.3.1"
+    "@nestjs/common": "10.3.3"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0",
     "@nestjs/microservices": "^10.0.0",
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/websockets": "^10.0.0",
-    "reflect-metadata": "^0.1.12",
+    "reflect-metadata": "^0.1.12 || ^0.2.0",
     "rxjs": "^7.1.0"
   },
   "peerDependenciesMeta": {