@nestjs/core 10.4.9 → 10.4.10

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/package.json

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