@depup/nestjs__core 11.1.17-depup.0

package/injector/module.js

@@ -0,0 +1,432 @@
+"use strict";
+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");
+const application_config_1 = require("../application-config");
+const exceptions_1 = require("../errors/exceptions");
+const context_id_factory_1 = require("../helpers/context-id-factory");
+const get_class_scope_1 = require("../helpers/get-class-scope");
+const is_durable_1 = require("../helpers/is-durable");
+const uuid_factory_1 = require("../inspector/uuid-factory");
+const constants_2 = require("./constants");
+const instance_wrapper_1 = require("./instance-wrapper");
+const module_ref_1 = require("./module-ref");
+class Module {
+    constructor(_metatype, container) {
+        this._metatype = _metatype;
+        this.container = container;
+        this._imports = new Set();
+        this._providers = new Map();
+        this._injectables = new Map();
+        this._middlewares = new Map();
+        this._controllers = new Map();
+        this._entryProviderKeys = new Set();
+        this._exports = new Set();
+        this._distance = 0;
+        this._initOnPreview = false;
+        this._isGlobal = false;
+        this.addCoreProviders();
+        this._id = this.generateUuid();
+    }
+    get id() {
+        return this._id;
+    }
+    get token() {
+        return this._token;
+    }
+    set token(token) {
+        this._token = token;
+    }
+    get name() {
+        return this.metatype.name;
+    }
+    get isGlobal() {
+        return this._isGlobal;
+    }
+    set isGlobal(global) {
+        this._isGlobal = global;
+    }
+    get initOnPreview() {
+        return this._initOnPreview;
+    }
+    set initOnPreview(initOnPreview) {
+        this._initOnPreview = initOnPreview;
+    }
+    get providers() {
+        return this._providers;
+    }
+    get middlewares() {
+        return this._middlewares;
+    }
+    get imports() {
+        return this._imports;
+    }
+    get injectables() {
+        return this._injectables;
+    }
+    get controllers() {
+        return this._controllers;
+    }
+    get entryProviders() {
+        return Array.from(this._entryProviderKeys).map(token => this.providers.get(token));
+    }
+    get exports() {
+        return this._exports;
+    }
+    get instance() {
+        if (!this._providers.has(this._metatype)) {
+            throw new exceptions_1.RuntimeException();
+        }
+        const moduleRef = this._providers.get(this._metatype);
+        return moduleRef.instance;
+    }
+    get metatype() {
+        return this._metatype;
+    }
+    get distance() {
+        return this._distance;
+    }
+    set distance(value) {
+        this._distance = value;
+    }
+    addCoreProviders() {
+        this.addModuleAsProvider();
+        this.addModuleRef();
+        this.addApplicationConfig();
+    }
+    addModuleRef() {
+        const moduleRef = this.createModuleReferenceType();
+        this._providers.set(module_ref_1.ModuleRef, new instance_wrapper_1.InstanceWrapper({
+            token: module_ref_1.ModuleRef,
+            name: module_ref_1.ModuleRef.name,
+            metatype: module_ref_1.ModuleRef,
+            isResolved: true,
+            instance: new moduleRef(),
+            host: this,
+        }));
+    }
+    addModuleAsProvider() {
+        this._providers.set(this._metatype, new instance_wrapper_1.InstanceWrapper({
+            token: this._metatype,
+            name: this._metatype.name,
+            metatype: this._metatype,
+            isResolved: false,
+            instance: null,
+            host: this,
+        }));
+    }
+    addApplicationConfig() {
+        this._providers.set(application_config_1.ApplicationConfig, new instance_wrapper_1.InstanceWrapper({
+            token: application_config_1.ApplicationConfig,
+            name: application_config_1.ApplicationConfig.name,
+            isResolved: true,
+            instance: this.container.applicationConfig,
+            host: this,
+        }));
+    }
+    addInjectable(injectable, enhancerSubtype, host) {
+        if (this.isCustomProvider(injectable)) {
+            return this.addCustomProvider(injectable, this._injectables, enhancerSubtype);
+        }
+        let instanceWrapper = this.injectables.get(injectable);
+        if (!instanceWrapper) {
+            instanceWrapper = new instance_wrapper_1.InstanceWrapper({
+                token: injectable,
+                name: injectable.name,
+                metatype: injectable,
+                instance: null,
+                isResolved: false,
+                scope: (0, get_class_scope_1.getClassScope)(injectable),
+                durable: (0, is_durable_1.isDurable)(injectable),
+                subtype: enhancerSubtype,
+                host: this,
+            });
+            this._injectables.set(injectable, instanceWrapper);
+        }
+        if (host) {
+            const hostWrapper = this._controllers.get(host) || this._providers.get(host);
+            hostWrapper && hostWrapper.addEnhancerMetadata(instanceWrapper);
+        }
+        return instanceWrapper;
+    }
+    addProvider(provider, enhancerSubtype) {
+        if (this.isCustomProvider(provider)) {
+            if (this.isEntryProvider(provider.provide)) {
+                this._entryProviderKeys.add(provider.provide);
+            }
+            return this.addCustomProvider(provider, this._providers, enhancerSubtype);
+        }
+        const isAlreadyDeclared = this._providers.has(provider);
+        if ((this.isTransientProvider(provider) ||
+            this.isRequestScopeProvider(provider)) &&
+            isAlreadyDeclared) {
+            return provider;
+        }
+        this._providers.set(provider, new instance_wrapper_1.InstanceWrapper({
+            token: provider,
+            name: provider.name,
+            metatype: provider,
+            instance: null,
+            isResolved: false,
+            scope: (0, get_class_scope_1.getClassScope)(provider),
+            durable: (0, is_durable_1.isDurable)(provider),
+            host: this,
+        }));
+        if (this.isEntryProvider(provider)) {
+            this._entryProviderKeys.add(provider);
+        }
+        return provider;
+    }
+    isCustomProvider(provider) {
+        return !(0, shared_utils_1.isNil)(provider.provide);
+    }
+    addCustomProvider(provider, collection, enhancerSubtype) {
+        if (this.isCustomClass(provider)) {
+            this.addCustomClass(provider, collection, enhancerSubtype);
+        }
+        else if (this.isCustomValue(provider)) {
+            this.addCustomValue(provider, collection, enhancerSubtype);
+        }
+        else if (this.isCustomFactory(provider)) {
+            this.addCustomFactory(provider, collection, enhancerSubtype);
+        }
+        else if (this.isCustomUseExisting(provider)) {
+            this.addCustomUseExisting(provider, collection, enhancerSubtype);
+        }
+        return provider.provide;
+    }
+    isCustomClass(provider) {
+        return !(0, shared_utils_1.isUndefined)(provider.useClass);
+    }
+    isCustomValue(provider) {
+        return ((0, shared_utils_1.isObject)(provider) &&
+            Object.prototype.hasOwnProperty.call(provider, 'useValue'));
+    }
+    isCustomFactory(provider) {
+        return !(0, shared_utils_1.isUndefined)(provider.useFactory);
+    }
+    isCustomUseExisting(provider) {
+        return !(0, shared_utils_1.isUndefined)(provider.useExisting);
+    }
+    isDynamicModule(exported) {
+        return exported && exported.module;
+    }
+    addCustomClass(provider, collection, enhancerSubtype) {
+        let { scope, durable } = provider;
+        const { useClass } = provider;
+        if ((0, shared_utils_1.isUndefined)(scope)) {
+            scope = (0, get_class_scope_1.getClassScope)(useClass);
+        }
+        if ((0, shared_utils_1.isUndefined)(durable)) {
+            durable = (0, is_durable_1.isDurable)(useClass);
+        }
+        const token = provider.provide;
+        collection.set(token, new instance_wrapper_1.InstanceWrapper({
+            token,
+            name: useClass?.name || useClass,
+            metatype: useClass,
+            instance: null,
+            isResolved: false,
+            scope,
+            durable,
+            host: this,
+            subtype: enhancerSubtype,
+        }));
+    }
+    addCustomValue(provider, collection, enhancerSubtype) {
+        const { useValue: value, provide: providerToken } = provider;
+        const instanceDecorator = this.container.contextOptions?.instrument?.instanceDecorator;
+        collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
+            token: providerToken,
+            name: providerToken?.name || providerToken,
+            metatype: null,
+            instance: instanceDecorator ? instanceDecorator(value) : value,
+            isResolved: true,
+            async: value instanceof Promise,
+            host: this,
+            subtype: enhancerSubtype,
+        }));
+    }
+    addCustomFactory(provider, collection, enhancerSubtype) {
+        const { useFactory: factory, inject, scope, durable, provide: providerToken, } = provider;
+        collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
+            token: providerToken,
+            name: providerToken?.name || providerToken,
+            metatype: factory,
+            instance: null,
+            isResolved: false,
+            inject: inject || [],
+            scope,
+            durable,
+            host: this,
+            subtype: enhancerSubtype,
+        }));
+    }
+    addCustomUseExisting(provider, collection, enhancerSubtype) {
+        const { useExisting, provide: providerToken } = provider;
+        collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
+            token: providerToken,
+            name: providerToken?.name || providerToken,
+            metatype: (instance => instance),
+            instance: null,
+            isResolved: false,
+            inject: [useExisting],
+            host: this,
+            isAlias: true,
+            subtype: enhancerSubtype,
+        }));
+    }
+    addExportedProviderOrModule(toExport) {
+        const addExportedUnit = (token) => this._exports.add(this.validateExportedProvider(token));
+        if (this.isCustomProvider(toExport)) {
+            return this.addCustomExportedProvider(toExport);
+        }
+        else if ((0, shared_utils_1.isString)(toExport) || (0, shared_utils_1.isSymbol)(toExport)) {
+            return addExportedUnit(toExport);
+        }
+        else if (this.isDynamicModule(toExport)) {
+            const { module: moduleClassRef } = toExport;
+            return addExportedUnit(moduleClassRef);
+        }
+        addExportedUnit(toExport);
+    }
+    addCustomExportedProvider(provider) {
+        const provide = provider.provide;
+        if ((0, shared_utils_1.isString)(provide) || (0, shared_utils_1.isSymbol)(provide)) {
+            return this._exports.add(this.validateExportedProvider(provide));
+        }
+        this._exports.add(this.validateExportedProvider(provide));
+    }
+    validateExportedProvider(token) {
+        if (this._providers.has(token)) {
+            return token;
+        }
+        const imports = (0, iterare_1.iterate)(this._imports.values())
+            .filter(item => !!item)
+            .map(({ metatype }) => metatype)
+            .filter(metatype => !!metatype)
+            .toArray();
+        if (!imports.includes(token)) {
+            const { name } = this.metatype;
+            const providerName = (0, shared_utils_1.isFunction)(token) ? token.name : token;
+            throw new exceptions_1.UnknownExportException(providerName, name);
+        }
+        return token;
+    }
+    addController(controller) {
+        this._controllers.set(controller, new instance_wrapper_1.InstanceWrapper({
+            token: controller,
+            name: controller.name,
+            metatype: controller,
+            instance: null,
+            isResolved: false,
+            scope: (0, get_class_scope_1.getClassScope)(controller),
+            durable: (0, is_durable_1.isDurable)(controller),
+            host: this,
+        }));
+        this.assignControllerUniqueId(controller);
+    }
+    assignControllerUniqueId(controller) {
+        Object.defineProperty(controller, constants_2.CONTROLLER_ID_KEY, {
+            enumerable: false,
+            writable: false,
+            configurable: true,
+            value: (0, random_string_generator_util_1.randomStringGenerator)(),
+        });
+    }
+    addImport(moduleRef) {
+        this._imports.add(moduleRef);
+    }
+    replace(toReplace, options) {
+        if (options.isProvider && this.hasProvider(toReplace)) {
+            const originalProvider = this._providers.get(toReplace);
+            return originalProvider.mergeWith({ provide: toReplace, ...options });
+        }
+        else if (!options.isProvider && this.hasInjectable(toReplace)) {
+            const originalInjectable = this._injectables.get(toReplace);
+            return originalInjectable.mergeWith({
+                provide: toReplace,
+                ...options,
+            });
+        }
+    }
+    hasProvider(token) {
+        return this._providers.has(token);
+    }
+    hasInjectable(token) {
+        return this._injectables.has(token);
+    }
+    getProviderByKey(name) {
+        return this._providers.get(name);
+    }
+    getProviderById(id) {
+        return Array.from(this._providers.values()).find(item => item.id === id);
+    }
+    getControllerById(id) {
+        return Array.from(this._controllers.values()).find(item => item.id === id);
+    }
+    getInjectableById(id) {
+        return Array.from(this._injectables.values()).find(item => item.id === id);
+    }
+    getMiddlewareById(id) {
+        return Array.from(this._middlewares.values()).find(item => item.id === id);
+    }
+    getNonAliasProviders() {
+        return [...this._providers].filter(([_, wrapper]) => !wrapper.isAlias);
+    }
+    createModuleReferenceType() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return class extends module_ref_1.ModuleRef {
+            constructor() {
+                super(self.container);
+            }
+            get(typeOrToken, options = {}) {
+                options.strict ??= true;
+                options.each ??= false;
+                return this.find(typeOrToken, options.strict
+                    ? {
+                        moduleId: self.id,
+                        each: options.each,
+                    }
+                    : options);
+            }
+            resolve(typeOrToken, contextId = (0, context_id_factory_1.createContextId)(), options = {}) {
+                options.strict ??= true;
+                options.each ??= false;
+                return this.resolvePerContext(typeOrToken, self, contextId, options);
+            }
+            async create(type, contextId) {
+                if (!(type && (0, shared_utils_1.isFunction)(type) && type.prototype)) {
+                    throw new exceptions_1.InvalidClassException(type);
+                }
+                return this.instantiateClass(type, self, contextId);
+            }
+        };
+    }
+    isEntryProvider(metatype) {
+        return typeof metatype === 'function'
+            ? !!Reflect.getMetadata(constants_1.ENTRY_PROVIDER_WATERMARK, metatype)
+            : false;
+    }
+    generateUuid() {
+        const prefix = 'M_';
+        const key = this.token
+            ? this.token.includes(':')
+                ? this.token.split(':')[1]
+                : this.token
+            : this.name;
+        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;
+    }
+    isRequestScopeProvider(provider) {
+        return (0, get_class_scope_1.getClassScope)(provider) === interfaces_1.Scope.REQUEST;
+    }
+}
+exports.Module = Module;

package/injector/modules-container.d.ts

@@ -0,0 +1,27 @@
+import { Observable } from 'rxjs';
+import { Module } from './module';
+export declare class ModulesContainer extends Map<string, Module> {
+    private readonly _applicationId;
+    private readonly _rpcTargetRegistry$;
+    /**
+     * Unique identifier of the application instance.
+     */
+    get applicationId(): string;
+    /**
+     * Retrieves a module by its identifier.
+     * @param id The identifier of the module to retrieve.
+     * @returns The module instance if found, otherwise undefined.
+     */
+    getById(id: string): Module | undefined;
+    /**
+     * Returns the RPC target registry as an observable.
+     * This registry contains all RPC targets registered in the application.
+     * @returns An observable that emits the RPC target registry.
+     */
+    getRpcTargetRegistry<T>(): Observable<T>;
+    /**
+     * Adds an RPC target to the registry.
+     * @param target The RPC target to add.
+     */
+    addRpcTarget<T>(target: T): void;
+}

package/injector/modules-container.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModulesContainer = void 0;
+const rxjs_1 = require("rxjs");
+const uid_1 = require("uid");
+class ModulesContainer extends Map {
+    constructor() {
+        super(...arguments);
+        this._applicationId = (0, uid_1.uid)(21);
+        this._rpcTargetRegistry$ = new rxjs_1.ReplaySubject();
+    }
+    /**
+     * Unique identifier of the application instance.
+     */
+    get applicationId() {
+        return this._applicationId;
+    }
+    /**
+     * Retrieves a module by its identifier.
+     * @param id The identifier of the module to retrieve.
+     * @returns The module instance if found, otherwise undefined.
+     */
+    getById(id) {
+        return Array.from(this.values()).find(moduleRef => moduleRef.id === id);
+    }
+    /**
+     * Returns the RPC target registry as an observable.
+     * This registry contains all RPC targets registered in the application.
+     * @returns An observable that emits the RPC target registry.
+     */
+    getRpcTargetRegistry() {
+        return this._rpcTargetRegistry$.asObservable();
+    }
+    /**
+     * Adds an RPC target to the registry.
+     * @param target The RPC target to add.
+     */
+    addRpcTarget(target) {
+        this._rpcTargetRegistry$.next(target);
+    }
+}
+exports.ModulesContainer = ModulesContainer;

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,41 @@
+"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 {
+            const delimiter = ':';
+            moduleId = dynamicMetadata
+                ? `${this.generateRandomString()}${delimiter}${this.hashString(moduleCls.name + JSON.stringify(dynamicMetadata))}`
+                : `${this.generateRandomString()}${delimiter}${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 });