@nestjs/core 9.3.1 → 9.3.3

package/Readme.md

@@ -11,7 +11,6 @@
 <a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/l/@nestjs/core.svg" alt="Package License" /></a>
 <a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/dm/@nestjs/common.svg" alt="NPM Downloads" /></a>
 <a href="https://circleci.com/gh/nestjs/nest" target="_blank"><img src="https://img.shields.io/circleci/build/github/nestjs/nest/master" alt="CircleCI" /></a>
-<a href="https://coveralls.io/github/nestjs/nest?branch=master" target="_blank"><img src="https://coveralls.io/repos/github/nestjs/nest/badge.svg?branch=master#9" alt="Coverage" /></a>
 <a href="https://discord.gg/G7Qnnhy" target="_blank"><img src="https://img.shields.io/badge/discord-online-brightgreen.svg" alt="Discord"/></a>
 <a href="https://opencollective.com/nest#backer" target="_blank"><img src="https://opencollective.com/nest/backers/badge.svg" alt="Backers on Open Collective" /></a>
 <a href="https://opencollective.com/nest#sponsor" target="_blank"><img src="https://opencollective.com/nest/sponsors/badge.svg" alt="Sponsors on Open Collective" /></a>

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 - 2022 Kamil Mysliwiec
+ * Copyright(c) 2017 - 2023 Kamil Mysliwiec
  * https://nestjs.com
  * MIT Licensed
  */

package/injector/compiler.d.ts

@@ -1,4 +1,4 @@
-import { DynamicModule, Type } from '@nestjs/common/interfaces';
+import { DynamicModule, ForwardReference, Type } from '@nestjs/common/interfaces';
 import { ModuleTokenFactory } from './module-token-factory';
 export interface ModuleFactory {
     type: Type<any>;
@@ -9,9 +9,9 @@ export declare class ModuleCompiler {
     private readonly moduleTokenFactory;
     constructor(moduleTokenFactory?: ModuleTokenFactory);
     compile(metatype: Type<any> | DynamicModule | Promise<DynamicModule>): Promise<ModuleFactory>;
-    extractMetadata(metatype: Type<any> | DynamicModule): {
+    extractMetadata(metatype: Type<any> | ForwardReference | DynamicModule): {
         type: Type<any>;
         dynamicMetadata?: Partial<DynamicModule> | undefined;
     };
-    isDynamicModule(module: Type<any> | DynamicModule): module is DynamicModule;
+    isDynamicModule(module: Type<any> | DynamicModule | ForwardReference): module is DynamicModule;
 }

package/injector/compiler.js

@@ -14,7 +14,11 @@ class ModuleCompiler {
     }
     extractMetadata(metatype) {
         if (!this.isDynamicModule(metatype)) {
-            return { type: metatype };
+            return {
+                type: (metatype === null || metatype === void 0 ? void 0 : metatype.forwardRef)
+                    ? metatype.forwardRef()
+                    : metatype,
+            };
         }
         const { module: type } = metatype, dynamicMetadata = tslib_1.__rest(metatype, ["module"]);
         return { type, dynamicMetadata };

package/injector/injector.js

@@ -162,7 +162,9 @@ class Injector {
         ];
     }
     reflectConstructorParams(type) {
-        const paramtypes = [...(Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, type) || [])];
+        const paramtypes = [
+            ...(Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, type) || []),
+        ];
         const selfParams = this.reflectSelfParams(type);
         selfParams.forEach(({ index, param }) => (paramtypes[index] = param));
         return paramtypes;

package/injector/instance-wrapper.js

@@ -109,9 +109,11 @@ class InstanceWrapper {
         if (!(0, shared_utils_1.isUndefined)(this.isTreeDurable)) {
             return this.isTreeDurable;
         }
-        if (this.durable === true) {
-            this.isTreeDurable = true;
-            this.printIntrospectedAsDurable();
+        if (this.scope === common_1.Scope.REQUEST) {
+            this.isTreeDurable = this.durable === undefined ? false : this.durable;
+            if (this.isTreeDurable) {
+                this.printIntrospectedAsDurable();
+            }
             return this.isTreeDurable;
         }
         const isStatic = this.isDependencyTreeStatic();
@@ -120,7 +122,7 @@ class InstanceWrapper {
         }
         const isTreeNonDurable = this.introspectDepsAttribute((collection, registry) => collection.some((item) => !item.isDependencyTreeStatic() &&
             !item.isDependencyTreeDurable(registry)), lookupRegistry);
-        this.isTreeDurable = !isTreeNonDurable && this.durable !== false;
+        this.isTreeDurable = !isTreeNonDurable;
         if (this.isTreeDurable) {
             this.printIntrospectedAsDurable();
         }
@@ -128,24 +130,23 @@ class InstanceWrapper {
     }
     introspectDepsAttribute(callback, lookupRegistry = []) {
         if (lookupRegistry.includes(this[exports.INSTANCE_ID_SYMBOL])) {
-            return true;
+            return false;
         }
         lookupRegistry = lookupRegistry.concat(this[exports.INSTANCE_ID_SYMBOL]);
         const { dependencies, properties, enhancers } = this[exports.INSTANCE_METADATA_SYMBOL];
-        let introspectionResult = (dependencies && callback(dependencies, lookupRegistry)) || !dependencies;
-        if (!introspectionResult || !(properties || enhancers)) {
+        let introspectionResult = dependencies
+            ? callback(dependencies, lookupRegistry)
+            : false;
+        if (introspectionResult || !(properties || enhancers)) {
             return introspectionResult;
         }
-        const propertiesHosts = (properties || []).map(item => item.wrapper);
-        introspectionResult =
-            introspectionResult &&
-                ((properties &&
-                    callback(properties.map(item => item.wrapper), lookupRegistry)) ||
-                    !properties);
-        if (!introspectionResult || !enhancers) {
+        introspectionResult = properties
+            ? callback(properties.map(item => item.wrapper), lookupRegistry)
+            : false;
+        if (introspectionResult || !enhancers) {
             return introspectionResult;
         }
-        return callback(enhancers, lookupRegistry);
+        return enhancers ? callback(enhancers, lookupRegistry) : false;
     }
     isDependencyTreeStatic(lookupRegistry = []) {
         if (!(0, shared_utils_1.isUndefined)(this.isTreeStatic)) {
@@ -156,7 +157,7 @@ class InstanceWrapper {
             this.printIntrospectedAsRequestScoped();
             return this.isTreeStatic;
         }
-        this.isTreeStatic = this.introspectDepsAttribute((collection, registry) => collection.every((item) => item.isDependencyTreeStatic(registry)), lookupRegistry);
+        this.isTreeStatic = !this.introspectDepsAttribute((collection, registry) => collection.some((item) => !item.isDependencyTreeStatic(registry)), lookupRegistry);
         if (!this.isTreeStatic) {
             this.printIntrospectedAsRequestScoped();
         }

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

@@ -1,10 +1,13 @@
 import { DynamicModule } from '@nestjs/common';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 export declare class ModuleTokenFactory {
+    private readonly moduleTokenCache;
     private readonly moduleIdsCache;
     create(metatype: Type<unknown>, dynamicModuleMetadata?: Partial<DynamicModule> | undefined): string;
-    getDynamicMetadataToken(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

@@ -3,28 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleTokenFactory = void 0;
 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 xxhash_1 = require("@node-rs/xxhash");
 const fast_safe_stringify_1 = require("fast-safe-stringify");
-const hash = require("object-hash");
+const CLASS_STR = 'class ';
+const CLASS_STR_LEN = CLASS_STR.length;
 class ModuleTokenFactory {
     constructor() {
+        this.moduleTokenCache = new Map();
         this.moduleIdsCache = new WeakMap();
     }
     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: this.getDynamicMetadataToken(dynamicModuleMetadata),
+            dynamic: dynamicModuleMetadata,
         };
-        return hash(opaqueToken, { ignoreUnknown: true });
+        const opaqueTokenString = this.getStringifiedOpaqueToken(opaqueToken);
+        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;
     }
-    getDynamicMetadataToken(dynamicModuleMetadata) {
+    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 dynamicModuleMetadata
-            ? (0, fast_safe_stringify_1.default)(dynamicModuleMetadata, this.replacer)
-            : '';
+        return opaqueToken ? (0, fast_safe_stringify_1.default)(opaqueToken, this.replacer) : '';
     }
     getModuleId(metatype) {
         let moduleId = this.moduleIdsCache.get(metatype);
@@ -38,14 +52,17 @@ class ModuleTokenFactory {
     getModuleName(metatype) {
         return metatype.name;
     }
+    hashString(value) {
+        return (0, xxhash_1.xxh32)(value).toString();
+    }
     replacer(key, value) {
         if ((0, shared_utils_1.isFunction)(value)) {
             const funcAsString = value.toString();
-            const isClass = /^class\s/.test(funcAsString);
+            const isClass = funcAsString.slice(0, CLASS_STR_LEN) === CLASS_STR;
             if (isClass) {
                 return value.name;
             }
-            return hash(funcAsString, { ignoreUnknown: true });
+            return funcAsString;
         }
         if ((0, shared_utils_1.isSymbol)(value)) {
             return value.toString();

package/injector/modules-container.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModulesContainer = void 0;
-const uuid_1 = require("uuid");
+const uid_1 = require("uid");
 class ModulesContainer extends Map {
     constructor() {
         super(...arguments);
-        this._applicationId = (0, uuid_1.v4)();
+        this._applicationId = (0, uid_1.uid)(21);
     }
     get applicationId() {
         return this._applicationId;

package/inspector/deterministic-uuid-registry.js

@@ -1,16 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeterministicUuidRegistry = void 0;
-const uuid_1 = require("uuid");
+const xxhash_1 = require("@node-rs/xxhash");
 const DEFAULT_UUID_NAMESPACE = 'efa0df42-88af-474f-9cad-4206a2319f07';
 class DeterministicUuidRegistry {
     static get(str, namespace = DEFAULT_UUID_NAMESPACE, inc = 0) {
-        const id = inc ? (0, uuid_1.v5)(str + `${inc}`, namespace) : (0, uuid_1.v5)(str, namespace);
-        if (this.registry.has(id)) {
+        const id = inc
+            ? (0, xxhash_1.xxh32)(`${namespace}_${str}_${inc}`)
+            : (0, xxhash_1.xxh32)(`${namespace}_${str}`);
+        const idAsString = `${id}`;
+        if (this.registry.has(idAsString)) {
             return this.get(str, namespace, inc + 1);
         }
-        this.registry.add(id);
-        return id;
+        this.registry.add(idAsString);
+        return idAsString;
     }
     static clear() {
         this.registry.clear();

package/inspector/uuid-factory.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UuidFactory = exports.UuidFactoryMode = void 0;
-const random_string_generator_util_1 = require("../../common/utils/random-string-generator.util");
+const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
 const deterministic_uuid_registry_1 = require("./deterministic-uuid-registry");
 var UuidFactoryMode;
 (function (UuidFactoryMode) {

package/metadata-scanner.d.ts

@@ -1,5 +1,13 @@
 import { Injectable } from '@nestjs/common/interfaces/injectable.interface';
 export declare class MetadataScanner {
+    private readonly cachedScannedPrototypes;
+    /**
+     * @deprecated Use {@link getAllMethodNames} instead.
+     */
     scanFromPrototype<T extends Injectable, R = any>(instance: T, prototype: object, callback: (name: string) => R): R[];
+    /**
+     * @deprecated Use {@link getAllMethodNames} instead.
+     */
     getAllFilteredMethodNames(prototype: object): IterableIterator<string>;
+    getAllMethodNames(prototype: object | null): string[];
 }

package/metadata-scanner.js

@@ -2,29 +2,78 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataScanner = void 0;
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const iterare_1 = require("iterare");
 class MetadataScanner {
+    constructor() {
+        this.cachedScannedPrototypes = new Map();
+    }
+    /**
+     * @deprecated Use {@link getAllMethodNames} instead.
+     */
     scanFromPrototype(instance, prototype, callback) {
-        const methodNames = new Set(this.getAllFilteredMethodNames(prototype));
-        return (0, iterare_1.iterate)(methodNames)
-            .map(callback)
-            .filter(metadata => !(0, shared_utils_1.isNil)(metadata))
-            .toArray();
+        if (!prototype) {
+            return [];
+        }
+        const visitedNames = new Map();
+        const result = [];
+        do {
+            for (const property of Object.getOwnPropertyNames(prototype)) {
+                if (visitedNames.has(property)) {
+                    continue;
+                }
+                visitedNames.set(property, true);
+                // reason: https://github.com/nestjs/nest/pull/10821#issuecomment-1411916533
+                const descriptor = Object.getOwnPropertyDescriptor(prototype, property);
+                if (descriptor.set ||
+                    descriptor.get ||
+                    (0, shared_utils_1.isConstructor)(property) ||
+                    !(0, shared_utils_1.isFunction)(prototype[property])) {
+                    continue;
+                }
+                const value = callback(property);
+                if ((0, shared_utils_1.isNil)(value)) {
+                    continue;
+                }
+                result.push(value);
+            }
+        } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
+            prototype !== Object.prototype);
+        return result;
     }
+    /**
+     * @deprecated Use {@link getAllMethodNames} instead.
+     */
     *getAllFilteredMethodNames(prototype) {
-        const isMethod = (prop) => {
-            const descriptor = Object.getOwnPropertyDescriptor(prototype, prop);
-            if (descriptor.set || descriptor.get) {
-                return false;
-            }
-            return !(0, shared_utils_1.isConstructor)(prop) && (0, shared_utils_1.isFunction)(prototype[prop]);
-        };
+        yield* this.getAllMethodNames(prototype);
+    }
+    getAllMethodNames(prototype) {
+        if (!prototype) {
+            return [];
+        }
+        if (this.cachedScannedPrototypes.has(prototype)) {
+            return this.cachedScannedPrototypes.get(prototype);
+        }
+        const visitedNames = new Map();
+        const result = [];
+        this.cachedScannedPrototypes.set(prototype, result);
         do {
-            yield* (0, iterare_1.iterate)(Object.getOwnPropertyNames(prototype))
-                .filter(isMethod)
-                .toArray();
+            for (const property of Object.getOwnPropertyNames(prototype)) {
+                if (visitedNames.has(property)) {
+                    continue;
+                }
+                visitedNames.set(property, true);
+                // reason: https://github.com/nestjs/nest/pull/10821#issuecomment-1411916533
+                const descriptor = Object.getOwnPropertyDescriptor(prototype, property);
+                if (descriptor.set ||
+                    descriptor.get ||
+                    (0, shared_utils_1.isConstructor)(property) ||
+                    !(0, shared_utils_1.isFunction)(prototype[property])) {
+                    continue;
+                }
+                result.push(property);
+            }
         } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
             prototype !== Object.prototype);
+        return result;
     }
 }
 exports.MetadataScanner = MetadataScanner;

package/middleware/builder.d.ts

@@ -1,11 +1,13 @@
 import { HttpServer, MiddlewareConsumer, Type } from '@nestjs/common/interfaces';
 import { MiddlewareConfigProxy, MiddlewareConfiguration } from '@nestjs/common/interfaces/middleware';
+import { RouteInfoPathExtractor } from './route-info-path-extractor';
 import { RoutesMapper } from './routes-mapper';
 export declare class MiddlewareBuilder implements MiddlewareConsumer {
     private readonly routesMapper;
     private readonly httpAdapter;
+    private readonly routeInfoPathExtractor;
     private readonly middlewareCollection;
-    constructor(routesMapper: RoutesMapper, httpAdapter: HttpServer);
+    constructor(routesMapper: RoutesMapper, httpAdapter: HttpServer, routeInfoPathExtractor: RouteInfoPathExtractor);
     apply(...middleware: Array<Type<any> | Function | any>): MiddlewareConfigProxy;
     build(): MiddlewareConfiguration[];
     getHttpAdapter(): HttpServer;

package/middleware/builder.js

@@ -5,13 +5,14 @@ const dependencies_decorator_1 = require("@nestjs/common/decorators/core/depende
 const iterare_1 = require("iterare");
 const utils_1 = require("./utils");
 class MiddlewareBuilder {
-    constructor(routesMapper, httpAdapter) {
+    constructor(routesMapper, httpAdapter, routeInfoPathExtractor) {
         this.routesMapper = routesMapper;
         this.httpAdapter = httpAdapter;
+        this.routeInfoPathExtractor = routeInfoPathExtractor;
         this.middlewareCollection = new Set();
     }
     apply(...middleware) {
-        return new MiddlewareBuilder.ConfigProxy(this, (0, dependencies_decorator_1.flatten)(middleware));
+        return new MiddlewareBuilder.ConfigProxy(this, (0, dependencies_decorator_1.flatten)(middleware), this.routeInfoPathExtractor);
     }
     build() {
         return [...this.middlewareCollection];
@@ -22,16 +23,17 @@ class MiddlewareBuilder {
 }
 exports.MiddlewareBuilder = MiddlewareBuilder;
 MiddlewareBuilder.ConfigProxy = class {
-    constructor(builder, middleware) {
+    constructor(builder, middleware, routeInfoPathExtractor) {
         this.builder = builder;
         this.middleware = middleware;
+        this.routeInfoPathExtractor = routeInfoPathExtractor;
         this.excludedRoutes = [];
     }
     getExcludedRoutes() {
         return this.excludedRoutes;
     }
     exclude(...routes) {
-        this.excludedRoutes = this.getRoutesFlatList(routes);
+        this.excludedRoutes = this.getRoutesFlatList(routes).map(route => (Object.assign(Object.assign({}, route), { path: this.routeInfoPathExtractor.extractPathFrom(route) })));
         return this;
     }
     forRoutes(...routes) {

package/middleware/middleware-module.d.ts

@@ -6,10 +6,8 @@ import { NestContainer } from '../injector/container';
 import { Injector } from '../injector/injector';
 import { Module } from '../injector/module';
 import { GraphInspector } from '../inspector/graph-inspector';
-import { RoutePathFactory } from '../router/route-path-factory';
 import { MiddlewareContainer } from './container';
 export declare class MiddlewareModule<TAppOptions extends NestApplicationContextOptions = NestApplicationContextOptions> {
-    private readonly routePathFactory;
     private readonly routerProxy;
     private readonly exceptionFiltersCache;
     private readonly logger;
@@ -17,12 +15,11 @@ export declare class MiddlewareModule<TAppOptions extends NestApplicationContext
     private routerExceptionFilter;
     private routesMapper;
     private resolver;
-    private config;
     private container;
     private httpAdapter;
     private graphInspector;
     private appOptions;
-    constructor(routePathFactory: RoutePathFactory);
+    private routeInfoPathExtractor;
     register(middlewareContainer: MiddlewareContainer, container: NestContainer, config: ApplicationConfig, injector: Injector, httpAdapter: HttpServer, graphInspector: GraphInspector, options: TAppOptions): Promise<void>;
     resolveMiddleware(middlewareContainer: MiddlewareContainer, modules: Map<string, Module>): Promise<void>;
     loadConfiguration(middlewareContainer: MiddlewareContainer, moduleRef: Module, moduleKey: string): Promise<void>;

package/middleware/middleware-module.js

@@ -15,10 +15,10 @@ const router_proxy_1 = require("../router/router-proxy");
 const utils_1 = require("../router/utils");
 const builder_1 = require("./builder");
 const resolver_1 = require("./resolver");
+const route_info_path_extractor_1 = require("./route-info-path-extractor");
 const routes_mapper_1 = require("./routes-mapper");
 class MiddlewareModule {
-    constructor(routePathFactory) {
-        this.routePathFactory = routePathFactory;
+    constructor() {
         this.routerProxy = new router_proxy_1.RouterProxy();
         this.exceptionFiltersCache = new WeakMap();
         this.logger = new common_1.Logger(MiddlewareModule.name);
@@ -29,7 +29,7 @@ class MiddlewareModule {
         this.routerExceptionFilter = new router_exception_filters_1.RouterExceptionFilters(container, config, appRef);
         this.routesMapper = new routes_mapper_1.RoutesMapper(container);
         this.resolver = new resolver_1.MiddlewareResolver(middlewareContainer, injector);
-        this.config = config;
+        this.routeInfoPathExtractor = new route_info_path_extractor_1.RouteInfoPathExtractor(config);
         this.injector = injector;
         this.container = container;
         this.httpAdapter = httpAdapter;
@@ -50,7 +50,7 @@ class MiddlewareModule {
         if (!instance.configure) {
             return;
         }
-        const middlewareBuilder = new builder_1.MiddlewareBuilder(this.routesMapper, this.httpAdapter);
+        const middlewareBuilder = new builder_1.MiddlewareBuilder(this.routesMapper, this.httpAdapter, this.routeInfoPathExtractor);
         try {
             await instance.configure(middlewareBuilder);
         }
@@ -153,29 +153,9 @@ class MiddlewareModule {
         const middleware = instance.use.bind(instance);
         return this.routerProxy.createProxy(middleware, exceptionsHandler);
     }
-    async registerHandler(applicationRef, { path, method, version }, proxy) {
-        const prefix = this.config.getGlobalPrefix();
-        const excludedRoutes = this.config.getGlobalPrefixOptions().exclude;
-        const isAWildcard = ['*', '/*', '(.*)', '/(.*)'].includes(path);
-        if ((Array.isArray(excludedRoutes) &&
-            (0, utils_1.isRouteExcluded)(excludedRoutes, path, method)) ||
-            isAWildcard) {
-            path = (0, shared_utils_1.addLeadingSlash)(path);
-        }
-        else {
-            const basePath = (0, shared_utils_1.addLeadingSlash)(prefix);
-            if ((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith('/')) && (path === null || path === void 0 ? void 0 : path.startsWith('/'))) {
-                // strip slash when a wildcard is being used
-                // and global prefix has been set
-                path = path === null || path === void 0 ? void 0 : path.slice(1);
-            }
-            path = basePath + path;
-        }
-        const applicationVersioningConfig = this.config.getVersioning();
-        if (version && applicationVersioningConfig.type === common_1.VersioningType.URI) {
-            const versionPrefix = this.routePathFactory.getVersionPrefix(applicationVersioningConfig);
-            path = `/${versionPrefix}${version.toString()}${path}`;
-        }
+    async registerHandler(applicationRef, routeInfo, proxy) {
+        const { method } = routeInfo;
+        const paths = this.routeInfoPathExtractor.extractPathsFrom(routeInfo);
         const isMethodAll = (0, utils_1.isRequestMethodAll)(method);
         const requestMethod = request_method_enum_1.RequestMethod[method];
         const router = await applicationRef.createMiddlewareFactory(method);
@@ -187,7 +167,7 @@ class MiddlewareModule {
                 }
                 return next();
             };
-        router(path, middlewareFunction);
+        paths.forEach(path => router(path, middlewareFunction));
     }
     getContextId(request, isTreeDurable) {
         const contextId = context_id_factory_1.ContextIdFactory.getByRequest(request);

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

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

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteInfoPathExtractor = void 0;
+const common_1 = require("@nestjs/common");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const utils_1 = require("../router/utils");
+const route_path_factory_1 = require("./../router/route-path-factory");
+class RouteInfoPathExtractor {
+    constructor(applicationConfig) {
+        this.applicationConfig = applicationConfig;
+        this.routePathFactory = new route_path_factory_1.RoutePathFactory(applicationConfig);
+        this.prefixPath = (0, shared_utils_1.stripEndSlash)((0, shared_utils_1.addLeadingSlash)(this.applicationConfig.getGlobalPrefix()));
+        this.excludedGlobalPrefixRoutes =
+            this.applicationConfig.getGlobalPrefixOptions().exclude;
+        this.versioningConfig = this.applicationConfig.getVersioning();
+    }
+    extractPathsFrom({ path, method, version }) {
+        const versionPath = this.extractVersionPathFrom(version);
+        if (this.isAWildcard(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)),
+                ]
+                : [this.prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path)];
+        }
+        return [this.extractNonWildcardPathFrom({ path, method, version })];
+    }
+    extractPathFrom(route) {
+        if (this.isAWildcard(route.path) && !route.version) {
+            return (0, shared_utils_1.addLeadingSlash)(route.path);
+        }
+        return this.extractNonWildcardPathFrom(route);
+    }
+    isAWildcard(path) {
+        return ['*', '/*', '/*/', '(.*)', '/(.*)'].includes(path);
+    }
+    extractNonWildcardPathFrom({ path, method, version, }) {
+        const versionPath = this.extractVersionPathFrom(version);
+        if (Array.isArray(this.excludedGlobalPrefixRoutes) &&
+            (0, utils_1.isRouteExcluded)(this.excludedGlobalPrefixRoutes, path, method)) {
+            return versionPath + (0, shared_utils_1.addLeadingSlash)(path);
+        }
+        return this.prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path);
+    }
+    extractVersionPathFrom(version) {
+        var _a;
+        if (!version || ((_a = this.versioningConfig) === null || _a === void 0 ? void 0 : _a.type) !== common_1.VersioningType.URI)
+            return '';
+        const versionPrefix = this.routePathFactory.getVersionPrefix(this.versioningConfig);
+        return (0, shared_utils_1.addLeadingSlash)(versionPrefix + version.toString());
+    }
+}
+exports.RouteInfoPathExtractor = RouteInfoPathExtractor;

package/middleware/utils.d.ts

@@ -1,8 +1,8 @@
 import { HttpServer, RouteInfo, Type } from '@nestjs/common/interfaces';
 import { ExcludeRouteMetadata } from '../router/interfaces/exclude-route-metadata.interface';
-export declare const mapToExcludeRoute: (routes: RouteInfo[]) => ExcludeRouteMetadata[];
+export declare const mapToExcludeRoute: (routes: (string | RouteInfo)[]) => ExcludeRouteMetadata[];
 export declare const filterMiddleware: <T extends Function | Type<any> = any>(middleware: T[], routes: RouteInfo[], httpAdapter: HttpServer) => Type<any>[];
 export declare const mapToClass: <T extends Function | Type<any>>(middleware: T, excludedRoutes: ExcludeRouteMetadata[], httpAdapter: HttpServer) => Type<any>;
 export declare function isMiddlewareClass(middleware: any): middleware is Type<any>;
-export declare function assignToken(metatype: Type<any>, token?: any): Type<any>;
+export declare function assignToken(metatype: Type<any>, token?: string): Type<any>;
 export declare function isMiddlewareRouteExcluded(req: Record<string, any>, excludedRoutes: ExcludeRouteMetadata[], httpAdapter: HttpServer): boolean;

package/middleware/utils.js

@@ -5,14 +5,23 @@ 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 uuid_1 = require("uuid");
+const uid_1 = require("uid");
 const utils_1 = require("../router/utils");
 const mapToExcludeRoute = (routes) => {
-    return routes.map(({ path, method }) => ({
-        pathRegex: pathToRegexp(path),
-        requestMethod: method,
-        path,
-    }));
+    return routes.map(route => {
+        if ((0, shared_utils_1.isString)(route)) {
+            return {
+                path: route,
+                requestMethod: common_1.RequestMethod.ALL,
+                pathRegex: pathToRegexp((0, shared_utils_1.addLeadingSlash)(route)),
+            };
+        }
+        return {
+            path: route.path,
+            requestMethod: route.method,
+            pathRegex: pathToRegexp((0, shared_utils_1.addLeadingSlash)(route.path)),
+        };
+    });
 };
 exports.mapToExcludeRoute = mapToExcludeRoute;
 const filterMiddleware = (middleware, routes, httpAdapter) => {
@@ -67,7 +76,7 @@ function isMiddlewareClass(middleware) {
         (0, shared_utils_1.isFunction)((_b = middleware.prototype) === null || _b === void 0 ? void 0 : _b.use));
 }
 exports.isMiddlewareClass = isMiddlewareClass;
-function assignToken(metatype, token = (0, uuid_1.v4)()) {
+function assignToken(metatype, token = (0, uid_1.uid)(21)) {
     Object.defineProperty(metatype, 'name', { value: token });
     return metatype;
 }

package/nest-application.js

@@ -7,15 +7,14 @@ const load_package_util_1 = require("@nestjs/common/utils/load-package.util");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const iterare_1 = require("iterare");
 const os_1 = require("os");
-const pathToRegexp = require("path-to-regexp");
 const application_config_1 = require("./application-config");
 const constants_1 = require("./constants");
 const optional_require_1 = require("./helpers/optional-require");
 const injector_1 = require("./injector/injector");
 const container_1 = require("./middleware/container");
 const middleware_module_1 = require("./middleware/middleware-module");
+const utils_1 = require("./middleware/utils");
 const nest_application_context_1 = require("./nest-application-context");
-const route_path_factory_1 = require("./router/route-path-factory");
 const routes_resolver_1 = require("./router/routes-resolver");
 const { SocketModule } = (0, optional_require_1.optionalRequire)('@nestjs/websockets/socket-module', () => require('@nestjs/websockets/socket-module'));
 const { MicroservicesModule } = (0, optional_require_1.optionalRequire)('@nestjs/microservices/microservices-module', () => require('@nestjs/microservices/microservices-module'));
@@ -39,7 +38,7 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         this.selectContextModule();
         this.registerHttpServer();
         this.injector = new injector_1.Injector({ preview: this.appOptions.preview });
-        this.middlewareModule = new middleware_module_1.MiddlewareModule(new route_path_factory_1.RoutePathFactory(config));
+        this.middlewareModule = new middleware_module_1.MiddlewareModule();
         this.routesResolver = new routes_resolver_1.RoutesResolver(this.container, this.config, this.injector, this.graphInspector);
     }
     async dispose() {
@@ -234,20 +233,9 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
     setGlobalPrefix(prefix, options) {
         this.config.setGlobalPrefix(prefix);
         if (options) {
-            const exclude = options === null || options === void 0 ? void 0 : options.exclude.map((route) => {
-                if ((0, shared_utils_1.isString)(route)) {
-                    return {
-                        requestMethod: common_1.RequestMethod.ALL,
-                        pathRegex: pathToRegexp((0, shared_utils_1.addLeadingSlash)(route)),
-                        path: route,
-                    };
-                }
-                return {
-                    requestMethod: route.method,
-                    pathRegex: pathToRegexp((0, shared_utils_1.addLeadingSlash)(route.path)),
-                    path: route.path,
-                };
-            });
+            const exclude = (options === null || options === void 0 ? void 0 : options.exclude)
+                ? (0, utils_1.mapToExcludeRoute)(options.exclude)
+                : [];
             this.config.setGlobalPrefixOptions(Object.assign(Object.assign({}, options), { exclude }));
         }
         return this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "9.3.1",
+  "version": "9.3.3",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -27,16 +27,15 @@
     }
   },
   "dependencies": {
+    "@node-rs/xxhash": "^1.3.0",
     "@nuxtjs/opencollective": "0.3.2",
     "fast-safe-stringify": "2.1.1",
     "iterare": "1.2.1",
-    "object-hash": "3.0.0",
     "path-to-regexp": "3.2.0",
-    "tslib": "2.4.1",
-    "uuid": "9.0.0"
+    "tslib": "2.5.0"
   },
   "devDependencies": {
-    "@nestjs/common": "9.3.1"
+    "@nestjs/common": "9.3.3"
   },
   "peerDependencies": {
     "@nestjs/common": "^9.0.0",

package/repl/native-functions/methods-repl-fn.js

@@ -18,7 +18,7 @@ class MethodsReplFn extends repl_function_1.ReplFunction {
         const proto = typeof token !== 'function'
             ? Object.getPrototypeOf(this.ctx.app.get(token))
             : token === null || token === void 0 ? void 0 : token.prototype;
-        const methods = new Set(this.metadataScanner.getAllFilteredMethodNames(proto));
+        const methods = this.metadataScanner.getAllMethodNames(proto);
         this.ctx.writeToStdout('\n');
         this.ctx.writeToStdout(`${cli_colors_util_1.clc.green('Methods')}:\n`);
         methods.forEach(methodName => this.ctx.writeToStdout(` ${cli_colors_util_1.clc.yellow('◻')} ${methodName}\n`));

package/router/interfaces/exclude-route-metadata.interface.d.ts

@@ -1,5 +1,8 @@
 import { RequestMethod } from '@nestjs/common';
 export interface ExcludeRouteMetadata {
+    /**
+     * Route path.
+     */
     path: string;
     /**
      * Regular expression representing the route path.

package/router/paths-explorer.d.ts

@@ -14,5 +14,5 @@ export declare class PathsExplorer {
     private readonly metadataScanner;
     constructor(metadataScanner: MetadataScanner);
     scanForPaths(instance: Controller, prototype?: object): RouteDefinition[];
-    exploreMethodMetadata(instance: Controller, prototype: object, methodName: string): RouteDefinition;
+    exploreMethodMetadata(instance: Controller, prototype: object, methodName: string): RouteDefinition | null;
 }

package/router/paths-explorer.js

@@ -11,7 +11,15 @@ class PathsExplorer {
         const instancePrototype = (0, shared_utils_1.isUndefined)(prototype)
             ? Object.getPrototypeOf(instance)
             : prototype;
-        return this.metadataScanner.scanFromPrototype(instance, instancePrototype, method => this.exploreMethodMetadata(instance, instancePrototype, method));
+        return this.metadataScanner
+            .getAllMethodNames(instancePrototype)
+            .reduce((acc, method) => {
+            const route = this.exploreMethodMetadata(instance, instancePrototype, method);
+            if (route) {
+                acc.push(route);
+            }
+            return acc;
+        }, []);
     }
     exploreMethodMetadata(instance, prototype, methodName) {
         const instanceCallback = instance[methodName];

package/router/utils/exclude-route.util.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRouteExcluded = exports.isRequestMethodAll = void 0;
 const common_1 = require("@nestjs/common");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const isRequestMethodAll = (method) => {
     return common_1.RequestMethod.ALL === method || method === -1;
 };
@@ -10,7 +11,7 @@ function isRouteExcluded(excludedRoutes, path, requestMethod) {
     return excludedRoutes.some(route => {
         if ((0, exports.isRequestMethodAll)(route.requestMethod) ||
             route.requestMethod === requestMethod) {
-            return route.pathRegex.exec(path);
+            return route.pathRegex.exec((0, shared_utils_1.addLeadingSlash)(path));
         }
         return false;
     });

package/scanner.d.ts

@@ -28,7 +28,7 @@ export declare class DependenciesScanner {
     reflectKeyMetadata(component: Type<Injectable>, key: string, methodKey: string): {
         methodKey: string;
         metadata: any;
-    };
+    } | undefined;
     calculateModulesDistance(): void;
     insertImport(related: any, token: string, context: string): Promise<void>;
     isCustomProvider(provider: Provider): provider is ClassProvider | ValueProvider | FactoryProvider | ExistingProvider;

package/scanner.js

@@ -133,19 +133,27 @@ class DependenciesScanner {
     }
     reflectInjectables(component, token, metadataKey) {
         const controllerInjectables = this.reflectMetadata(metadataKey, component);
-        const methodInjectables = this.metadataScanner.scanFromPrototype(null, component.prototype, this.reflectKeyMetadata.bind(this, component, metadataKey));
+        const methodInjectables = this.metadataScanner
+            .getAllMethodNames(component.prototype)
+            .reduce((acc, method) => {
+            const methodInjectable = this.reflectKeyMetadata(component, metadataKey, method);
+            if (methodInjectable) {
+                acc.push(methodInjectable);
+            }
+            return acc;
+        }, []);
         controllerInjectables.forEach(injectable => this.insertInjectable(injectable, token, component, constants_1.ENHANCER_KEY_TO_SUBTYPE_MAP[metadataKey]));
-        methodInjectables.forEach(({ methodKey, metadata }) => metadata.forEach(injectable => this.insertInjectable(injectable, token, component, constants_1.ENHANCER_KEY_TO_SUBTYPE_MAP[metadataKey], methodKey)));
+        methodInjectables.forEach(methodInjectable => {
+            methodInjectable.metadata.forEach(injectable => this.insertInjectable(injectable, token, component, constants_1.ENHANCER_KEY_TO_SUBTYPE_MAP[metadataKey], methodInjectable.methodKey));
+        });
     }
     reflectParamInjectables(component, token, metadataKey) {
-        const paramsMetadata = this.metadataScanner.scanFromPrototype(null, component.prototype, methodKey => {
+        const paramsMethods = this.metadataScanner.getAllMethodNames(component.prototype);
+        paramsMethods.forEach(methodKey => {
             const metadata = Reflect.getMetadata(metadataKey, component, methodKey);
             if (!metadata) {
                 return;
             }
-            return { methodKey, metadata };
-        });
-        paramsMetadata.forEach(({ methodKey, metadata }) => {
             const params = Object.values(metadata);
             params
                 .map(item => item.pipes)