@nestjs/core 10.4.8 → 10.4.10

package/injector/injector.js

@@ -153,13 +153,20 @@ class Injector {
     }
     getFactoryProviderDependencies(wrapper) {
         const optionalDependenciesIds = [];
-        const isOptionalFactoryDep = (item) => !(0, shared_utils_1.isUndefined)(item.token) &&
-            !(0, shared_utils_1.isUndefined)(item.optional);
+        /**
+         * Same as the internal utility function `isOptionalFactoryDependency` from `@nestjs/common`.
+         * We are duplicating it here because that one is not supposed to be exported.
+         */
+        function isOptionalFactoryDependency(value) {
+            return (!(0, shared_utils_1.isUndefined)(value.token) &&
+                !(0, shared_utils_1.isUndefined)(value.optional) &&
+                !value.prototype);
+        }
         const mapFactoryProviderInjectArray = (item, index) => {
             if (typeof item !== 'object') {
                 return item;
             }
-            if (isOptionalFactoryDep(item)) {
+            if (isOptionalFactoryDependency(item)) {
                 if (item.optional) {
                     optionalDependenciesIds.push(index);
                 }

package/injector/module.d.ts

@@ -81,4 +81,5 @@ export declare class Module {
     createModuleReferenceType(): Type<ModuleRef>;
     private isEntryProvider;
     private generateUuid;
+    private isTransientProvider;
 }

package/injector/module.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Module = void 0;
 const constants_1 = require("@nestjs/common/constants");
+const interfaces_1 = require("@nestjs/common/interfaces");
 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 iterare_1 = require("iterare");
@@ -159,6 +160,10 @@ class Module {
             }
             return this.addCustomProvider(provider, this._providers, enhancerSubtype);
         }
+        const isAlreadyDeclared = this._providers.has(provider);
+        if (this.isTransientProvider(provider) && isAlreadyDeclared) {
+            return provider;
+        }
         this._providers.set(provider, new instance_wrapper_1.InstanceWrapper({
             token: provider,
             name: provider.name,
@@ -416,5 +421,8 @@ class Module {
         const key = this.name?.toString() ?? this.token?.toString();
         return key ? uuid_factory_1.UuidFactory.get(`${prefix}_${key}`) : (0, random_string_generator_util_1.randomStringGenerator)();
     }
+    isTransientProvider(provider) {
+        return (0, get_class_scope_1.getClassScope)(provider) === interfaces_1.Scope.TRANSIENT;
+    }
 }
 exports.Module = Module;

package/injector/opaque-key-factory/by-reference-module-opaque-key-factory.d.ts

@@ -0,0 +1,15 @@
+import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
+import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+import { ModuleOpaqueKeyFactory } from './interfaces/module-opaque-key-factory.interface';
+export declare class ByReferenceModuleOpaqueKeyFactory implements ModuleOpaqueKeyFactory {
+    private readonly keyGenerationStrategy;
+    constructor(options?: {
+        keyGenerationStrategy: 'random' | 'shallow';
+    });
+    createForStatic(moduleCls: Type, originalRef?: Type | ForwardReference): string;
+    createForDynamic(moduleCls: Type<unknown>, dynamicMetadata: Omit<DynamicModule, 'module'>, originalRef: DynamicModule | ForwardReference): string;
+    private getOrCreateModuleId;
+    private hashString;
+    private generateRandomString;
+}

package/injector/opaque-key-factory/by-reference-module-opaque-key-factory.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByReferenceModuleOpaqueKeyFactory = void 0;
+const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
+const crypto_1 = require("crypto");
+const K_MODULE_ID = Symbol('K_MODULE_ID');
+class ByReferenceModuleOpaqueKeyFactory {
+    constructor(options) {
+        this.keyGenerationStrategy = options?.keyGenerationStrategy ?? 'random';
+    }
+    createForStatic(moduleCls, originalRef = moduleCls) {
+        return this.getOrCreateModuleId(moduleCls, undefined, originalRef);
+    }
+    createForDynamic(moduleCls, dynamicMetadata, originalRef) {
+        return this.getOrCreateModuleId(moduleCls, dynamicMetadata, originalRef);
+    }
+    getOrCreateModuleId(moduleCls, dynamicMetadata, originalRef) {
+        if (originalRef[K_MODULE_ID]) {
+            return originalRef[K_MODULE_ID];
+        }
+        let moduleId;
+        if (this.keyGenerationStrategy === 'random') {
+            moduleId = this.generateRandomString();
+        }
+        else {
+            moduleId = dynamicMetadata
+                ? `${this.generateRandomString()}:${this.hashString(moduleCls.name + JSON.stringify(dynamicMetadata))}`
+                : `${this.generateRandomString()}:${this.hashString(moduleCls.toString())}`;
+        }
+        originalRef[K_MODULE_ID] = moduleId;
+        return moduleId;
+    }
+    hashString(value) {
+        return (0, crypto_1.createHash)('sha256').update(value).digest('hex');
+    }
+    generateRandomString() {
+        return (0, random_string_generator_util_1.randomStringGenerator)();
+    }
+}
+exports.ByReferenceModuleOpaqueKeyFactory = ByReferenceModuleOpaqueKeyFactory;

package/injector/opaque-key-factory/deep-hashed-module-opaque-key-factory.d.ts

@@ -0,0 +1,15 @@
+import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+import { ModuleOpaqueKeyFactory } from './interfaces/module-opaque-key-factory.interface';
+export declare class DeepHashedModuleOpaqueKeyFactory implements ModuleOpaqueKeyFactory {
+    private readonly moduleIdsCache;
+    private readonly moduleTokenCache;
+    private readonly logger;
+    createForStatic(moduleCls: Type): string;
+    createForDynamic(moduleCls: Type<unknown>, dynamicMetadata: Omit<DynamicModule, 'module'>): string;
+    getStringifiedOpaqueToken(opaqueToken: object | undefined): string;
+    getModuleId(metatype: Type<unknown>): string;
+    getModuleName(metatype: Type<any>): string;
+    private hashString;
+    private replacer;
+}

package/injector/opaque-key-factory/deep-hashed-module-opaque-key-factory.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepHashedModuleOpaqueKeyFactory = void 0;
+const logger_service_1 = require("@nestjs/common/services/logger.service");
+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 CLASS_STR = 'class ';
+const CLASS_STR_LEN = CLASS_STR.length;
+class DeepHashedModuleOpaqueKeyFactory {
+    constructor() {
+        this.moduleIdsCache = new WeakMap();
+        this.moduleTokenCache = new Map();
+        this.logger = new logger_service_1.Logger(DeepHashedModuleOpaqueKeyFactory.name, {
+            timestamp: true,
+        });
+    }
+    createForStatic(moduleCls) {
+        const moduleId = this.getModuleId(moduleCls);
+        const moduleName = this.getModuleName(moduleCls);
+        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;
+    }
+    createForDynamic(moduleCls, dynamicMetadata) {
+        const moduleId = this.getModuleId(moduleCls);
+        const moduleName = this.getModuleName(moduleCls);
+        const opaqueToken = {
+            id: moduleId,
+            module: moduleName,
+            dynamic: dynamicMetadata,
+        };
+        const start = performance.now();
+        const opaqueTokenString = this.getStringifiedOpaqueToken(opaqueToken);
+        const timeSpentInMs = 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. Consider changing the "moduleIdGeneratorAlgorithm" option to "reference" to improve the performance.`);
+        }
+        return this.hashString(opaqueTokenString);
+    }
+    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 opaqueToken ? (0, fast_safe_stringify_1.default)(opaqueToken, this.replacer) : '';
+    }
+    getModuleId(metatype) {
+        let moduleId = this.moduleIdsCache.get(metatype);
+        if (moduleId) {
+            return moduleId;
+        }
+        moduleId = (0, random_string_generator_util_1.randomStringGenerator)();
+        this.moduleIdsCache.set(metatype, moduleId);
+        return moduleId;
+    }
+    getModuleName(metatype) {
+        return metatype.name;
+    }
+    hashString(value) {
+        return (0, crypto_1.createHash)('sha256').update(value).digest('hex');
+    }
+    replacer(key, value) {
+        if ((0, shared_utils_1.isFunction)(value)) {
+            const funcAsString = value.toString();
+            const isClass = funcAsString.slice(0, CLASS_STR_LEN) === CLASS_STR;
+            if (isClass) {
+                return value.name;
+            }
+            return funcAsString;
+        }
+        if ((0, shared_utils_1.isSymbol)(value)) {
+            return value.toString();
+        }
+        return value;
+    }
+}
+exports.DeepHashedModuleOpaqueKeyFactory = DeepHashedModuleOpaqueKeyFactory;

package/injector/opaque-key-factory/interfaces/module-opaque-key-factory.interface.d.ts

@@ -0,0 +1,18 @@
+import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
+import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+export interface ModuleOpaqueKeyFactory {
+    /**
+     * Creates a unique opaque key for the given static module.
+     * @param moduleCls A static module class.
+     * @param originalRef Original object reference. In most cases, it's the same as `moduleCls`.
+     */
+    createForStatic(moduleCls: Type, originalRef: Type | ForwardReference): string;
+    /**
+     * Creates a unique opaque key for the given dynamic module.
+     * @param moduleCls  A dynamic module class reference.
+     * @param dynamicMetadata Dynamic module metadata.
+     * @param originalRef Original object reference.
+     */
+    createForDynamic(moduleCls: Type<unknown>, dynamicMetadata: Omit<DynamicModule, 'module'>, originalRef: DynamicModule | ForwardReference): string;
+}

package/injector/opaque-key-factory/interfaces/module-opaque-key-factory.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/middleware/middleware-module.js

@@ -182,7 +182,9 @@ class MiddlewareModule {
                 writable: false,
                 configurable: false,
             });
-            const requestProviderValue = isTreeDurable ? contextId.payload : request;
+            const requestProviderValue = isTreeDurable
+                ? contextId.payload
+                : Object.assign(request, contextId.payload);
             this.container.registerRequestProvider(requestProviderValue, contextId);
         }
         return contextId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "10.4.8",
+  "version": "10.4.10",
   "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.4.8"
+    "@nestjs/common": "10.4.10"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0",

package/router/router-explorer.js

@@ -196,7 +196,9 @@ class RouterExplorer {
                 writable: false,
                 configurable: false,
             });
-            const requestProviderValue = isTreeDurable ? contextId.payload : request;
+            const requestProviderValue = isTreeDurable
+                ? contextId.payload
+                : Object.assign(request, contextId.payload);
             this.container.registerRequestProvider(requestProviderValue, contextId);
         }
         return contextId;