@nestjs/core 11.1.16 → 12.0.0-alpha.0

package/injector/module-ref.js

@@ -1,36 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleRef = void 0;
-const common_1 = require("@nestjs/common");
-const get_class_scope_1 = require("../helpers/get-class-scope");
-const is_durable_1 = require("../helpers/is-durable");
-const abstract_instance_resolver_1 = require("./abstract-instance-resolver");
-const injector_1 = require("./injector");
-const instance_links_host_1 = require("./instance-links-host");
-const instance_wrapper_1 = require("./instance-wrapper");
-class ModuleRef extends abstract_instance_resolver_1.AbstractInstanceResolver {
+import { Scope } from '@nestjs/common';
+import { getClassScope } from '../helpers/get-class-scope.js';
+import { isDurable } from '../helpers/is-durable.js';
+import { AbstractInstanceResolver } from './abstract-instance-resolver.js';
+import { Injector } from './injector.js';
+import { InstanceLinksHost } from './instance-links-host.js';
+import { InstanceWrapper } from './instance-wrapper.js';
+export class ModuleRef extends AbstractInstanceResolver {
+    container;
+    injector;
+    _instanceLinksHost;
     get instanceLinksHost() {
         if (!this._instanceLinksHost) {
-            this._instanceLinksHost = new instance_links_host_1.InstanceLinksHost(this.container);
+            this._instanceLinksHost = new InstanceLinksHost(this.container);
         }
         return this._instanceLinksHost;
     }
     constructor(container) {
         super();
         this.container = container;
-        this.injector = new injector_1.Injector({
+        this.injector = new Injector({
             preview: container.contextOptions?.preview,
             instanceDecorator: container.contextOptions?.instrument?.instanceDecorator,
         });
     }
     introspect(token) {
         const { wrapperRef } = this.instanceLinksHost.get(token);
-        let scope = common_1.Scope.DEFAULT;
+        let scope = Scope.DEFAULT;
         if (!wrapperRef.isDependencyTreeStatic()) {
-            scope = common_1.Scope.REQUEST;
+            scope = Scope.REQUEST;
         }
         else if (wrapperRef.isTransient) {
-            scope = common_1.Scope.TRANSIENT;
+            scope = Scope.TRANSIENT;
         }
         return { scope };
     }
@@ -38,12 +38,12 @@ class ModuleRef extends abstract_instance_resolver_1.AbstractInstanceResolver {
         this.container.registerRequestProvider(request, contextId);
     }
     async instantiateClass(type, moduleRef, contextId) {
-        const wrapper = new instance_wrapper_1.InstanceWrapper({
+        const wrapper = new InstanceWrapper({
             name: type && type.name,
             metatype: type,
             isResolved: false,
-            scope: (0, get_class_scope_1.getClassScope)(type),
-            durable: (0, is_durable_1.isDurable)(type),
+            scope: getClassScope(type),
+            durable: isDurable(type),
             host: moduleRef,
         });
         /* eslint-disable-next-line no-async-promise-executor */
@@ -63,4 +63,3 @@ class ModuleRef extends abstract_instance_resolver_1.AbstractInstanceResolver {
         });
     }
 }
-exports.ModuleRef = ModuleRef;

package/injector/module.d.ts

@@ -1,8 +1,8 @@
-import { EnhancerSubtype } from '@nestjs/common/constants';
-import { ClassProvider, Controller, DynamicModule, ExistingProvider, FactoryProvider, Injectable, InjectionToken, NestModule, Provider, Type, ValueProvider } from '@nestjs/common/interfaces';
-import { NestContainer } from './container';
-import { InstanceWrapper } from './instance-wrapper';
-import { ModuleRef } from './module-ref';
+import { NestContainer } from './container.js';
+import { InstanceWrapper } from './instance-wrapper.js';
+import { ModuleRef } from './module-ref.js';
+import { type EnhancerSubtype, type Controller, type Injectable } from '@nestjs/common/internal';
+import { type ClassProvider, type DynamicModule, type ExistingProvider, type FactoryProvider, type InjectionToken, type NestModule, type Provider, type Type, type ValueProvider } from '@nestjs/common';
 export declare class Module {
     private readonly _metatype;
     private readonly container;

package/injector/module.js

@@ -1,34 +1,33 @@
-"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 {
+import { iterate } from 'iterare';
+import { ApplicationConfig } from '../application-config.js';
+import { InvalidClassException, RuntimeException, UnknownExportException, } from '../errors/exceptions/index.js';
+import { createContextId } from '../helpers/context-id-factory.js';
+import { getClassScope } from '../helpers/get-class-scope.js';
+import { isDurable } from '../helpers/is-durable.js';
+import { UuidFactory } from '../inspector/uuid-factory.js';
+import { CONTROLLER_ID_KEY } from './constants.js';
+import { InstanceWrapper } from './instance-wrapper.js';
+import { ModuleRef } from './module-ref.js';
+import { ENTRY_PROVIDER_WATERMARK, randomStringGenerator, isFunction, isNil, isObject, isString, isSymbol, isUndefined, } from '@nestjs/common/internal';
+import { Scope, } from '@nestjs/common';
+export class Module {
+    _metatype;
+    container;
+    _id;
+    _imports = new Set();
+    _providers = new Map();
+    _injectables = new Map();
+    _middlewares = new Map();
+    _controllers = new Map();
+    _entryProviderKeys = new Set();
+    _exports = new Set();
+    _distance = 0;
+    _initOnPreview = false;
+    _isGlobal = false;
+    _token;
     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();
     }
@@ -79,7 +78,7 @@ class Module {
     }
     get instance() {
         if (!this._providers.has(this._metatype)) {
-            throw new exceptions_1.RuntimeException();
+            throw new RuntimeException();
         }
         const moduleRef = this._providers.get(this._metatype);
         return moduleRef.instance;
@@ -100,17 +99,17 @@ class Module {
     }
     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,
+        this._providers.set(ModuleRef, new InstanceWrapper({
+            token: ModuleRef,
+            name: ModuleRef.name,
+            metatype: ModuleRef,
             isResolved: true,
             instance: new moduleRef(),
             host: this,
         }));
     }
     addModuleAsProvider() {
-        this._providers.set(this._metatype, new instance_wrapper_1.InstanceWrapper({
+        this._providers.set(this._metatype, new InstanceWrapper({
             token: this._metatype,
             name: this._metatype.name,
             metatype: this._metatype,
@@ -120,9 +119,9 @@ class Module {
         }));
     }
     addApplicationConfig() {
-        this._providers.set(application_config_1.ApplicationConfig, new instance_wrapper_1.InstanceWrapper({
-            token: application_config_1.ApplicationConfig,
-            name: application_config_1.ApplicationConfig.name,
+        this._providers.set(ApplicationConfig, new InstanceWrapper({
+            token: ApplicationConfig,
+            name: ApplicationConfig.name,
             isResolved: true,
             instance: this.container.applicationConfig,
             host: this,
@@ -134,14 +133,14 @@ class Module {
         }
         let instanceWrapper = this.injectables.get(injectable);
         if (!instanceWrapper) {
-            instanceWrapper = new instance_wrapper_1.InstanceWrapper({
+            instanceWrapper = new 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),
+                scope: getClassScope(injectable),
+                durable: isDurable(injectable),
                 subtype: enhancerSubtype,
                 host: this,
             });
@@ -166,14 +165,14 @@ class Module {
             isAlreadyDeclared) {
             return provider;
         }
-        this._providers.set(provider, new instance_wrapper_1.InstanceWrapper({
+        this._providers.set(provider, new 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),
+            scope: getClassScope(provider),
+            durable: isDurable(provider),
             host: this,
         }));
         if (this.isEntryProvider(provider)) {
@@ -182,7 +181,7 @@ class Module {
         return provider;
     }
     isCustomProvider(provider) {
-        return !(0, shared_utils_1.isNil)(provider.provide);
+        return !isNil(provider.provide);
     }
     addCustomProvider(provider, collection, enhancerSubtype) {
         if (this.isCustomClass(provider)) {
@@ -200,17 +199,17 @@ class Module {
         return provider.provide;
     }
     isCustomClass(provider) {
-        return !(0, shared_utils_1.isUndefined)(provider.useClass);
+        return !isUndefined(provider.useClass);
     }
     isCustomValue(provider) {
-        return ((0, shared_utils_1.isObject)(provider) &&
+        return (isObject(provider) &&
             Object.prototype.hasOwnProperty.call(provider, 'useValue'));
     }
     isCustomFactory(provider) {
-        return !(0, shared_utils_1.isUndefined)(provider.useFactory);
+        return !isUndefined(provider.useFactory);
     }
     isCustomUseExisting(provider) {
-        return !(0, shared_utils_1.isUndefined)(provider.useExisting);
+        return !isUndefined(provider.useExisting);
     }
     isDynamicModule(exported) {
         return exported && exported.module;
@@ -218,14 +217,14 @@ class 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 (isUndefined(scope)) {
+            scope = getClassScope(useClass);
         }
-        if ((0, shared_utils_1.isUndefined)(durable)) {
-            durable = (0, is_durable_1.isDurable)(useClass);
+        if (isUndefined(durable)) {
+            durable = isDurable(useClass);
         }
         const token = provider.provide;
-        collection.set(token, new instance_wrapper_1.InstanceWrapper({
+        collection.set(token, new InstanceWrapper({
             token,
             name: useClass?.name || useClass,
             metatype: useClass,
@@ -240,7 +239,7 @@ class Module {
     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({
+        collection.set(providerToken, new InstanceWrapper({
             token: providerToken,
             name: providerToken?.name || providerToken,
             metatype: null,
@@ -253,7 +252,7 @@ class Module {
     }
     addCustomFactory(provider, collection, enhancerSubtype) {
         const { useFactory: factory, inject, scope, durable, provide: providerToken, } = provider;
-        collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
+        collection.set(providerToken, new InstanceWrapper({
             token: providerToken,
             name: providerToken?.name || providerToken,
             metatype: factory,
@@ -268,7 +267,7 @@ class Module {
     }
     addCustomUseExisting(provider, collection, enhancerSubtype) {
         const { useExisting, provide: providerToken } = provider;
-        collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
+        collection.set(providerToken, new InstanceWrapper({
             token: providerToken,
             name: providerToken?.name || providerToken,
             metatype: (instance => instance),
@@ -285,7 +284,7 @@ class Module {
         if (this.isCustomProvider(toExport)) {
             return this.addCustomExportedProvider(toExport);
         }
-        else if ((0, shared_utils_1.isString)(toExport) || (0, shared_utils_1.isSymbol)(toExport)) {
+        else if (isString(toExport) || isSymbol(toExport)) {
             return addExportedUnit(toExport);
         }
         else if (this.isDynamicModule(toExport)) {
@@ -296,7 +295,7 @@ class Module {
     }
     addCustomExportedProvider(provider) {
         const provide = provider.provide;
-        if ((0, shared_utils_1.isString)(provide) || (0, shared_utils_1.isSymbol)(provide)) {
+        if (isString(provide) || isSymbol(provide)) {
             return this._exports.add(this.validateExportedProvider(provide));
         }
         this._exports.add(this.validateExportedProvider(provide));
@@ -305,37 +304,37 @@ class Module {
         if (this._providers.has(token)) {
             return token;
         }
-        const imports = (0, iterare_1.iterate)(this._imports.values())
+        const imports = 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);
+            const providerName = isFunction(token) ? token.name : token;
+            throw new UnknownExportException(providerName, name);
         }
         return token;
     }
     addController(controller) {
-        this._controllers.set(controller, new instance_wrapper_1.InstanceWrapper({
+        this._controllers.set(controller, new 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),
+            scope: getClassScope(controller),
+            durable: isDurable(controller),
             host: this,
         }));
         this.assignControllerUniqueId(controller);
     }
     assignControllerUniqueId(controller) {
-        Object.defineProperty(controller, constants_2.CONTROLLER_ID_KEY, {
+        Object.defineProperty(controller, CONTROLLER_ID_KEY, {
             enumerable: false,
             writable: false,
             configurable: true,
-            value: (0, random_string_generator_util_1.randomStringGenerator)(),
+            value: randomStringGenerator(),
         });
     }
     addImport(moduleRef) {
@@ -364,16 +363,32 @@ class Module {
         return this._providers.get(name);
     }
     getProviderById(id) {
-        return Array.from(this._providers.values()).find(item => item.id === id);
+        for (const item of this._providers.values()) {
+            if (item.id === id)
+                return item;
+        }
+        return undefined;
     }
     getControllerById(id) {
-        return Array.from(this._controllers.values()).find(item => item.id === id);
+        for (const item of this._controllers.values()) {
+            if (item.id === id)
+                return item;
+        }
+        return undefined;
     }
     getInjectableById(id) {
-        return Array.from(this._injectables.values()).find(item => item.id === id);
+        for (const item of this._injectables.values()) {
+            if (item.id === id)
+                return item;
+        }
+        return undefined;
     }
     getMiddlewareById(id) {
-        return Array.from(this._middlewares.values()).find(item => item.id === id);
+        for (const item of this._middlewares.values()) {
+            if (item.id === id)
+                return item;
+        }
+        return undefined;
     }
     getNonAliasProviders() {
         return [...this._providers].filter(([_, wrapper]) => !wrapper.isAlias);
@@ -381,7 +396,7 @@ class Module {
     createModuleReferenceType() {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
-        return class extends module_ref_1.ModuleRef {
+        return class extends ModuleRef {
             constructor() {
                 super(self.container);
             }
@@ -395,14 +410,14 @@ class Module {
                     }
                     : options);
             }
-            resolve(typeOrToken, contextId = (0, context_id_factory_1.createContextId)(), options = {}) {
+            resolve(typeOrToken, contextId = 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);
+                if (!(type && isFunction(type) && type.prototype)) {
+                    throw new InvalidClassException(type);
                 }
                 return this.instantiateClass(type, self, contextId);
             }
@@ -410,7 +425,7 @@ class Module {
     }
     isEntryProvider(metatype) {
         return typeof metatype === 'function'
-            ? !!Reflect.getMetadata(constants_1.ENTRY_PROVIDER_WATERMARK, metatype)
+            ? !!Reflect.getMetadata(ENTRY_PROVIDER_WATERMARK, metatype)
             : false;
     }
     generateUuid() {
@@ -420,13 +435,12 @@ class Module {
                 ? this.token.split(':')[1]
                 : this.token
             : this.name;
-        return key ? uuid_factory_1.UuidFactory.get(`${prefix}_${key}`) : (0, random_string_generator_util_1.randomStringGenerator)();
+        return key ? UuidFactory.get(`${prefix}_${key}`) : randomStringGenerator();
     }
     isTransientProvider(provider) {
-        return (0, get_class_scope_1.getClassScope)(provider) === interfaces_1.Scope.TRANSIENT;
+        return getClassScope(provider) === Scope.TRANSIENT;
     }
     isRequestScopeProvider(provider) {
-        return (0, get_class_scope_1.getClassScope)(provider) === interfaces_1.Scope.REQUEST;
+        return getClassScope(provider) === Scope.REQUEST;
     }
 }
-exports.Module = Module;

package/injector/modules-container.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { Module } from './module';
+import { Module } from './module.js';
 export declare class ModulesContainer extends Map<string, Module> {
     private readonly _applicationId;
     private readonly _rpcTargetRegistry$;

package/injector/modules-container.js

@@ -1,14 +1,8 @@
-"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();
-    }
+import { ReplaySubject } from 'rxjs';
+import { uid } from 'uid';
+export class ModulesContainer extends Map {
+    _applicationId = uid(21);
+    _rpcTargetRegistry$ = new ReplaySubject();
     /**
      * Unique identifier of the application instance.
      */
@@ -39,4 +33,3 @@ class ModulesContainer extends Map {
         this._rpcTargetRegistry$.next(target);
     }
 }
-exports.ModulesContainer = ModulesContainer;

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

@@ -1,7 +1,5 @@
-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';
+import { ModuleOpaqueKeyFactory } from './interfaces/module-opaque-key-factory.interface.js';
+import type { DynamicModule, ForwardReference, Type } from '@nestjs/common';
 export declare class ByReferenceModuleOpaqueKeyFactory implements ModuleOpaqueKeyFactory {
     private readonly keyGenerationStrategy;
     constructor(options?: {

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

@@ -1,10 +1,8 @@
-"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");
+import { createHash } from 'crypto';
+import { randomStringGenerator } from '@nestjs/common/internal';
 const K_MODULE_ID = Symbol('K_MODULE_ID');
-class ByReferenceModuleOpaqueKeyFactory {
+export class ByReferenceModuleOpaqueKeyFactory {
+    keyGenerationStrategy;
     constructor(options) {
         this.keyGenerationStrategy = options?.keyGenerationStrategy ?? 'random';
     }
@@ -32,10 +30,9 @@ class ByReferenceModuleOpaqueKeyFactory {
         return moduleId;
     }
     hashString(value) {
-        return (0, crypto_1.createHash)('sha256').update(value).digest('hex');
+        return createHash('sha256').update(value).digest('hex');
     }
     generateRandomString() {
-        return (0, random_string_generator_util_1.randomStringGenerator)();
+        return randomStringGenerator();
     }
 }
-exports.ByReferenceModuleOpaqueKeyFactory = ByReferenceModuleOpaqueKeyFactory;

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

@@ -1,6 +1,5 @@
-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';
+import { ModuleOpaqueKeyFactory } from './interfaces/module-opaque-key-factory.interface.js';
+import { type DynamicModule, type Type } from '@nestjs/common';
 export declare class DeepHashedModuleOpaqueKeyFactory implements ModuleOpaqueKeyFactory {
     private readonly moduleIdsCache;
     private readonly moduleTokenCache;

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

@@ -1,21 +1,17 @@
-"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");
+import { createHash } from 'crypto';
+import _stringify from 'fast-safe-stringify';
+import { Logger } from '@nestjs/common';
+import { randomStringGenerator, isFunction, isSymbol, } from '@nestjs/common/internal';
+// CJS interop: fast-safe-stringify sets module.exports.default = module.exports
+const stringify = (_stringify.default ?? _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,
-        });
-    }
+export class DeepHashedModuleOpaqueKeyFactory {
+    moduleIdsCache = new WeakMap();
+    moduleTokenCache = new Map();
+    logger = new Logger(DeepHashedModuleOpaqueKeyFactory.name, {
+        timestamp: true,
+    });
     createForStatic(moduleCls) {
         const moduleId = this.getModuleId(moduleCls);
         const moduleName = this.getModuleName(moduleCls);
@@ -48,14 +44,14 @@ class DeepHashedModuleOpaqueKeyFactory {
         // 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) : '';
+        return opaqueToken ? stringify(opaqueToken, this.replacer) : '';
     }
     getModuleId(metatype) {
         let moduleId = this.moduleIdsCache.get(metatype);
         if (moduleId) {
             return moduleId;
         }
-        moduleId = (0, random_string_generator_util_1.randomStringGenerator)();
+        moduleId = randomStringGenerator();
         this.moduleIdsCache.set(metatype, moduleId);
         return moduleId;
     }
@@ -63,10 +59,10 @@ class DeepHashedModuleOpaqueKeyFactory {
         return metatype.name;
     }
     hashString(value) {
-        return (0, crypto_1.createHash)('sha256').update(value).digest('hex');
+        return createHash('sha256').update(value).digest('hex');
     }
     replacer(key, value) {
-        if ((0, shared_utils_1.isFunction)(value)) {
+        if (isFunction(value)) {
             const funcAsString = value.toString();
             const isClass = funcAsString.slice(0, CLASS_STR_LEN) === CLASS_STR;
             if (isClass) {
@@ -74,10 +70,9 @@ class DeepHashedModuleOpaqueKeyFactory {
             }
             return funcAsString;
         }
-        if ((0, shared_utils_1.isSymbol)(value)) {
+        if (isSymbol(value)) {
             return value.toString();
         }
         return value;
     }
 }
-exports.DeepHashedModuleOpaqueKeyFactory = DeepHashedModuleOpaqueKeyFactory;

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

@@ -1,6 +1,4 @@
-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 type { DynamicModule, ForwardReference, Type } from '@nestjs/common';
 export interface ModuleOpaqueKeyFactory {
     /**
      * Creates a unique opaque key for the given static module.

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

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