@nestjs/core 10.2.7 → 10.2.9

package/discovery/discoverable-meta-host-collection.js

@@ -43,11 +43,11 @@ class DiscoverableMetaHostCollection {
     }
     static getProvidersByMetaKey(hostContainerRef, metaKey) {
         const wrappersByMetaKey = this.providersByMetaKey.get(hostContainerRef);
-        return wrappersByMetaKey.get(metaKey);
+        return wrappersByMetaKey?.get(metaKey) ?? new Set();
     }
     static getControllersByMetaKey(hostContainerRef, metaKey) {
         const wrappersByMetaKey = this.controllersByMetaKey.get(hostContainerRef);
-        return wrappersByMetaKey.get(metaKey);
+        return wrappersByMetaKey?.get(metaKey) ?? new Set();
     }
     static inspectInstanceWrapper(hostContainerRef, instanceWrapper, wrapperByMetaKeyMap) {
         const metaKey = DiscoverableMetaHostCollection.getMetaKeyByInstanceWrapper(instanceWrapper);

package/errors/messages.js

@@ -16,20 +16,27 @@ const getInstanceName = (instance) => {
     return instance?.name;
 };
 /**
- * Returns the name of the dependency
+ * Returns the name of the dependency.
  * Tries to get the class name, otherwise the string value
- * (= injection token). As fallback it returns '+'
+ * (= injection token). As fallback to any falsy value for `dependency`, it
+ * returns `fallbackValue`
  * @param dependency The name of the dependency to be displayed
+ * @param fallbackValue The fallback value if the dependency is falsy
+ * @param disambiguated Whether dependency's name is disambiguated with double quotes
  */
-const getDependencyName = (dependency) => 
+const getDependencyName = (dependency, fallbackValue, disambiguated = true) => 
 // use class name
 getInstanceName(dependency) ||
     // use injection token (symbol)
     ((0, shared_utils_1.isSymbol)(dependency) && dependency.toString()) ||
     // use string directly
-    dependency ||
+    (dependency
+        ? disambiguated
+            ? `"${dependency}"`
+            : dependency
+        : undefined) ||
     // otherwise
-    '+';
+    fallbackValue;
 /**
  * Returns the name of the module
  * Tries to get the class name. As fallback it returns 'current'.
@@ -38,9 +45,9 @@ getInstanceName(dependency) ||
 const getModuleName = (module) => (module && getInstanceName(module.metatype)) || 'current';
 const stringifyScope = (scope) => (scope || []).map(getInstanceName).join(' -> ');
 const UNKNOWN_DEPENDENCIES_MESSAGE = (type, unknownDependencyContext, module) => {
-    const { index, name = 'dependency', dependencies, key, } = unknownDependencyContext;
+    const { index, name, dependencies, key } = unknownDependencyContext;
     const moduleName = getModuleName(module);
-    const dependencyName = getDependencyName(name);
+    const dependencyName = getDependencyName(name, 'dependency');
     const potentialSolutions = 
     // If module's name is well defined
     moduleName !== 'current'
@@ -66,7 +73,7 @@ Potential solutions:
         message += `. Please make sure that the "${key.toString()}" property is available in the current context.${potentialSolutions}`;
         return message;
     }
-    const dependenciesName = (dependencies || []).map(getDependencyName);
+    const dependenciesName = (dependencies || []).map(dependencyName => getDependencyName(dependencyName, '+', false));
     dependenciesName[index] = '?';
     message += ` (`;
     message += dependenciesName.join(', ');

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

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

package/injector/module-token-factory.js

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleTokenFactory = void 0;
+const common_1 = require("@nestjs/common");
 const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const crypto_1 = require("crypto");
 const fast_safe_stringify_1 = require("fast-safe-stringify");
+const perf_hooks_1 = require("perf_hooks");
 const CLASS_STR = 'class ';
 const CLASS_STR_LEN = CLASS_STR.length;
 class ModuleTokenFactory {
     constructor() {
         this.moduleTokenCache = new Map();
         this.moduleIdsCache = new WeakMap();
+        this.logger = new common_1.Logger(ModuleTokenFactory.name, {
+            timestamp: true,
+        });
     }
     create(metatype, dynamicModuleMetadata) {
         const moduleId = this.getModuleId(metatype);
@@ -22,7 +27,13 @@ class ModuleTokenFactory {
             module: this.getModuleName(metatype),
             dynamic: dynamicModuleMetadata,
         };
+        const start = perf_hooks_1.performance.now();
         const opaqueTokenString = this.getStringifiedOpaqueToken(opaqueToken);
+        const timeSpentInMs = perf_hooks_1.performance.now() - start;
+        if (timeSpentInMs > 10) {
+            const formattedTimeSpent = timeSpentInMs.toFixed(2);
+            this.logger.warn(`The module "${opaqueToken.module}" is taking ${formattedTimeSpent}ms to serialize, this may be caused by larger objects statically assigned to the module. More details: https://github.com/nestjs/nest/issues/12738`);
+        }
         return this.hashString(opaqueTokenString);
     }
     getStaticModuleToken(moduleId, moduleName) {

package/middleware/routes-mapper.js

@@ -50,8 +50,7 @@ class RoutesMapper {
         const modulePath = this.getModulePath(moduleRef?.metatype);
         const concatPaths = (acc, currentValue) => acc.concat(currentValue);
         const toUndefinedIfNeural = (version) => version === interfaces_1.VERSION_NEUTRAL ? undefined : version;
-        const toRouteInfo = (item, prefix) => item.path
-            ?.flatMap(p => {
+        const toRouteInfo = (item, prefix) => item.path?.flatMap(p => {
             let endpointPath = modulePath ?? '';
             endpointPath += this.normalizeGlobalPath(prefix) + (0, shared_utils_1.addLeadingSlash)(p);
             const routeInfo = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "10.2.7",
+  "version": "10.2.9",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -36,7 +36,7 @@
     "uid": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "10.2.7"
+    "@nestjs/common": "10.2.9"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0",

package/router/interfaces/routes.interface.d.ts

@@ -2,6 +2,6 @@ import { Type } from '@nestjs/common';
 export interface RouteTree {
     path: string;
     module?: Type<any>;
-    children?: Routes | Type<any>[];
+    children?: (RouteTree | Type<any>)[];
 }
 export type Routes = RouteTree[];