@nestjs/core 9.3.2 → 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/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/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.js

@@ -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);
         }

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

@@ -3,6 +3,13 @@ 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

@@ -9,30 +9,46 @@ 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 prefixPath = (0, shared_utils_1.stripEndSlash)((0, shared_utils_1.addLeadingSlash)(this.applicationConfig.getGlobalPrefix()));
-        const excludedRoutes = this.applicationConfig.getGlobalPrefixOptions().exclude;
-        const applicationVersioningConfig = this.applicationConfig.getVersioning();
-        let versionPath = '';
-        if (version && (applicationVersioningConfig === null || applicationVersioningConfig === void 0 ? void 0 : applicationVersioningConfig.type) === common_1.VersioningType.URI) {
-            const versionPrefix = this.routePathFactory.getVersionPrefix(applicationVersioningConfig);
-            versionPath = (0, shared_utils_1.addLeadingSlash)(versionPrefix + version.toString());
-        }
-        const isAWildcard = ['*', '/*', '/*/', '(.*)', '/(.*)'].includes(path);
-        if (isAWildcard) {
-            return Array.isArray(excludedRoutes)
+        const versionPath = this.extractVersionPathFrom(version);
+        if (this.isAWildcard(path)) {
+            return Array.isArray(this.excludedGlobalPrefixRoutes)
                 ? [
-                    prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path),
-                    ...excludedRoutes.map(route => versionPath + (0, shared_utils_1.addLeadingSlash)(route.path)),
+                    this.prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(path),
+                    ...this.excludedGlobalPrefixRoutes.map(route => versionPath + (0, shared_utils_1.addLeadingSlash)(route.path)),
                 ]
-                : [prefixPath + versionPath + (0, shared_utils_1.addLeadingSlash)(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);
         }
-        if (Array.isArray(excludedRoutes) &&
-            (0, utils_1.isRouteExcluded)(excludedRoutes, path, method)) {
-            return [versionPath + (0, shared_utils_1.addLeadingSlash)(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 [prefixPath + 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

@@ -4,5 +4,5 @@ export declare const mapToExcludeRoute: (routes: (string | RouteInfo)[]) => Excl
 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,7 +5,7 @@ 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(route => {
@@ -76,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "9.3.2",
+  "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.5.0",
-    "uuid": "9.0.0"
+    "tslib": "2.5.0"
   },
   "devDependencies": {
-    "@nestjs/common": "9.3.2"
+    "@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/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/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)