@depup/nestjs__core 11.1.17-depup.0

package/injector/container.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestContainer = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const discoverable_meta_host_collection_1 = require("../discovery/discoverable-meta-host-collection");
+const exceptions_1 = require("../errors/exceptions");
+const initialize_on_preview_allowlist_1 = require("../inspector/initialize-on-preview.allowlist");
+const serialized_graph_1 = require("../inspector/serialized-graph");
+const request_constants_1 = require("../router/request/request-constants");
+const compiler_1 = require("./compiler");
+const internal_core_module_1 = require("./internal-core-module/internal-core-module");
+const internal_providers_storage_1 = require("./internal-providers-storage");
+const module_1 = require("./module");
+const modules_container_1 = require("./modules-container");
+const by_reference_module_opaque_key_factory_1 = require("./opaque-key-factory/by-reference-module-opaque-key-factory");
+const deep_hashed_module_opaque_key_factory_1 = require("./opaque-key-factory/deep-hashed-module-opaque-key-factory");
+class NestContainer {
+    constructor(_applicationConfig = undefined, _contextOptions = undefined) {
+        this._applicationConfig = _applicationConfig;
+        this._contextOptions = _contextOptions;
+        this.globalModules = new Set();
+        this.modules = new modules_container_1.ModulesContainer();
+        this.dynamicModulesMetadata = new Map();
+        this.internalProvidersStorage = new internal_providers_storage_1.InternalProvidersStorage();
+        this._serializedGraph = new serialized_graph_1.SerializedGraph();
+        const moduleOpaqueKeyFactory = this._contextOptions?.moduleIdGeneratorAlgorithm === 'deep-hash'
+            ? new deep_hashed_module_opaque_key_factory_1.DeepHashedModuleOpaqueKeyFactory()
+            : new by_reference_module_opaque_key_factory_1.ByReferenceModuleOpaqueKeyFactory({
+                keyGenerationStrategy: this._contextOptions?.snapshot
+                    ? 'shallow'
+                    : 'random',
+            });
+        this.moduleCompiler = new compiler_1.ModuleCompiler(moduleOpaqueKeyFactory);
+    }
+    get serializedGraph() {
+        return this._serializedGraph;
+    }
+    get applicationConfig() {
+        return this._applicationConfig;
+    }
+    get contextOptions() {
+        return this._contextOptions;
+    }
+    setHttpAdapter(httpAdapter) {
+        this.internalProvidersStorage.httpAdapter = httpAdapter;
+        if (!this.internalProvidersStorage.httpAdapterHost) {
+            return;
+        }
+        const host = this.internalProvidersStorage.httpAdapterHost;
+        host.httpAdapter = httpAdapter;
+    }
+    getHttpAdapterRef() {
+        return this.internalProvidersStorage.httpAdapter;
+    }
+    getHttpAdapterHostRef() {
+        return this.internalProvidersStorage.httpAdapterHost;
+    }
+    async addModule(metatype, scope) {
+        // In DependenciesScanner#scanForModules we already check for undefined or invalid modules
+        // We still need to catch the edge-case of `forwardRef(() => undefined)`
+        if (!metatype) {
+            throw new exceptions_1.UndefinedForwardRefException(scope);
+        }
+        const { type, dynamicMetadata, token } = await this.moduleCompiler.compile(metatype);
+        if (this.modules.has(token)) {
+            return {
+                moduleRef: this.modules.get(token),
+                inserted: true,
+            };
+        }
+        return {
+            moduleRef: await this.setModule({
+                token,
+                type,
+                dynamicMetadata,
+            }, scope),
+            inserted: true,
+        };
+    }
+    async replaceModule(metatypeToReplace, newMetatype, scope) {
+        // In DependenciesScanner#scanForModules we already check for undefined or invalid modules
+        // We still need to catch the edge-case of `forwardRef(() => undefined)`
+        if (!metatypeToReplace || !newMetatype) {
+            throw new exceptions_1.UndefinedForwardRefException(scope);
+        }
+        const { token } = await this.moduleCompiler.compile(metatypeToReplace);
+        const { type, dynamicMetadata } = await this.moduleCompiler.compile(newMetatype);
+        return {
+            moduleRef: await this.setModule({
+                token,
+                type,
+                dynamicMetadata,
+            }, scope),
+            inserted: false,
+        };
+    }
+    async setModule({ token, dynamicMetadata, type }, scope) {
+        const moduleRef = new module_1.Module(type, this);
+        moduleRef.token = token;
+        moduleRef.initOnPreview = this.shouldInitOnPreview(type);
+        this.modules.set(token, moduleRef);
+        const updatedScope = [].concat(scope, type);
+        await this.addDynamicMetadata(token, dynamicMetadata, updatedScope);
+        if (this.isGlobalModule(type, dynamicMetadata)) {
+            moduleRef.isGlobal = true;
+            // Set global module distance to MAX_VALUE to ensure their lifecycle hooks
+            // are always executed first (when initializing the application)
+            moduleRef.distance = Number.MAX_VALUE;
+            this.addGlobalModule(moduleRef);
+        }
+        return moduleRef;
+    }
+    async addDynamicMetadata(token, dynamicModuleMetadata, scope) {
+        if (!dynamicModuleMetadata) {
+            return;
+        }
+        this.dynamicModulesMetadata.set(token, dynamicModuleMetadata);
+        const { imports } = dynamicModuleMetadata;
+        await this.addDynamicModules(imports, scope);
+    }
+    async addDynamicModules(modules, scope) {
+        if (!modules) {
+            return;
+        }
+        await Promise.all(modules.map(module => this.addModule(module, scope)));
+    }
+    isGlobalModule(metatype, dynamicMetadata) {
+        if (dynamicMetadata && dynamicMetadata.global) {
+            return true;
+        }
+        return !!Reflect.getMetadata(constants_1.GLOBAL_MODULE_METADATA, metatype);
+    }
+    addGlobalModule(module) {
+        this.globalModules.add(module);
+    }
+    getModules() {
+        return this.modules;
+    }
+    getModuleCompiler() {
+        return this.moduleCompiler;
+    }
+    getModuleByKey(moduleKey) {
+        return this.modules.get(moduleKey);
+    }
+    getInternalCoreModuleRef() {
+        return this.internalCoreModule;
+    }
+    async addImport(relatedModule, token) {
+        if (!this.modules.has(token)) {
+            return;
+        }
+        const moduleRef = this.modules.get(token);
+        const { token: relatedModuleToken } = await this.moduleCompiler.compile(relatedModule);
+        const related = this.modules.get(relatedModuleToken);
+        moduleRef.addImport(related);
+    }
+    addProvider(provider, token, enhancerSubtype) {
+        const moduleRef = this.modules.get(token);
+        if (!provider) {
+            throw new exceptions_1.CircularDependencyException(moduleRef?.metatype.name);
+        }
+        if (!moduleRef) {
+            throw new exceptions_1.UnknownModuleException();
+        }
+        const providerKey = moduleRef.addProvider(provider, enhancerSubtype);
+        const providerRef = moduleRef.getProviderByKey(providerKey);
+        discoverable_meta_host_collection_1.DiscoverableMetaHostCollection.inspectProvider(this.modules, providerRef);
+        return providerKey;
+    }
+    addInjectable(injectable, token, enhancerSubtype, host) {
+        if (!this.modules.has(token)) {
+            throw new exceptions_1.UnknownModuleException();
+        }
+        const moduleRef = this.modules.get(token);
+        return moduleRef.addInjectable(injectable, enhancerSubtype, host);
+    }
+    addExportedProviderOrModule(toExport, token) {
+        if (!this.modules.has(token)) {
+            throw new exceptions_1.UnknownModuleException();
+        }
+        const moduleRef = this.modules.get(token);
+        moduleRef.addExportedProviderOrModule(toExport);
+    }
+    addController(controller, token) {
+        if (!this.modules.has(token)) {
+            throw new exceptions_1.UnknownModuleException();
+        }
+        const moduleRef = this.modules.get(token);
+        moduleRef.addController(controller);
+        const controllerRef = moduleRef.controllers.get(controller);
+        discoverable_meta_host_collection_1.DiscoverableMetaHostCollection.inspectController(this.modules, controllerRef);
+    }
+    clear() {
+        this.modules.clear();
+    }
+    replace(toReplace, options) {
+        this.modules.forEach(moduleRef => moduleRef.replace(toReplace, options));
+    }
+    bindGlobalScope() {
+        this.modules.forEach(moduleRef => this.bindGlobalsToImports(moduleRef));
+    }
+    bindGlobalsToImports(moduleRef) {
+        this.globalModules.forEach(globalModule => this.bindGlobalModuleToModule(moduleRef, globalModule));
+    }
+    bindGlobalModuleToModule(target, globalModule) {
+        if (target === globalModule || target === this.internalCoreModule) {
+            return;
+        }
+        target.addImport(globalModule);
+    }
+    getDynamicMetadataByToken(token, metadataKey) {
+        const metadata = this.dynamicModulesMetadata.get(token);
+        return metadataKey ? (metadata?.[metadataKey] ?? []) : metadata;
+    }
+    registerCoreModuleRef(moduleRef) {
+        this.internalCoreModule = moduleRef;
+        this.modules[internal_core_module_1.InternalCoreModule.name] = moduleRef;
+    }
+    getModuleTokenFactory() {
+        return this.moduleCompiler.moduleOpaqueKeyFactory;
+    }
+    registerRequestProvider(request, contextId) {
+        const wrapper = this.internalCoreModule.getProviderByKey(request_constants_1.REQUEST);
+        wrapper.setInstanceByContextId(contextId, {
+            instance: request,
+            isResolved: true,
+        });
+    }
+    shouldInitOnPreview(type) {
+        return initialize_on_preview_allowlist_1.InitializeOnPreviewAllowlist.has(type);
+    }
+}
+exports.NestContainer = NestContainer;

package/injector/helpers/provider-classifier.d.ts

@@ -0,0 +1,4 @@
+import { ClassProvider, FactoryProvider, Provider, ValueProvider } from '@nestjs/common';
+export declare function isClassProvider<T = any>(provider: Provider): provider is ClassProvider<T>;
+export declare function isValueProvider<T = any>(provider: Provider): provider is ValueProvider<T>;
+export declare function isFactoryProvider<T = any>(provider: Provider): provider is FactoryProvider<T>;

package/injector/helpers/provider-classifier.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClassProvider = isClassProvider;
+exports.isValueProvider = isValueProvider;
+exports.isFactoryProvider = isFactoryProvider;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+function isClassProvider(provider) {
+    return Boolean(provider?.useClass);
+}
+function isValueProvider(provider) {
+    const providerValue = provider?.useValue;
+    return !(0, shared_utils_1.isUndefined)(providerValue);
+}
+function isFactoryProvider(provider) {
+    return Boolean(provider.useFactory);
+}

package/injector/helpers/silent-logger.d.ts

@@ -0,0 +1,10 @@
+import { Logger } from '@nestjs/common';
+export declare class SilentLogger extends Logger {
+    log: () => void;
+    error: () => void;
+    warn: () => void;
+    debug: () => void;
+    verbose: () => void;
+    fatal: () => void;
+    setLogLevels: () => void;
+}

package/injector/helpers/silent-logger.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SilentLogger = void 0;
+const common_1 = require("@nestjs/common");
+const noop = () => { };
+class SilentLogger extends common_1.Logger {
+    constructor() {
+        super(...arguments);
+        this.log = noop;
+        this.error = noop;
+        this.warn = noop;
+        this.debug = noop;
+        this.verbose = noop;
+        this.fatal = noop;
+        this.setLogLevels = noop;
+    }
+}
+exports.SilentLogger = SilentLogger;

package/injector/helpers/transient-instances.d.ts

@@ -0,0 +1,12 @@
+import { InjectionToken } from '@nestjs/common';
+import { InstanceWrapper } from '../instance-wrapper';
+/**
+ * Returns the instances which are transient
+ * @param instances The instances which should be checked whether they are transient
+ */
+export declare function getTransientInstances(instances: [InjectionToken, InstanceWrapper][]): InstanceWrapper[];
+/**
+ * Returns the instances which are not transient
+ * @param instances The instances which should be checked whether they are transient
+ */
+export declare function getNonTransientInstances(instances: [InjectionToken, InstanceWrapper][]): InstanceWrapper[];

package/injector/helpers/transient-instances.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransientInstances = getTransientInstances;
+exports.getNonTransientInstances = getNonTransientInstances;
+const iterare_1 = require("iterare");
+/**
+ * Returns the instances which are transient
+ * @param instances The instances which should be checked whether they are transient
+ */
+function getTransientInstances(instances) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(([_, wrapper]) => wrapper.isDependencyTreeStatic())
+        .map(([_, wrapper]) => wrapper.getStaticTransientInstances())
+        .flatten()
+        .filter(item => !!item)
+        .map(({ instance }) => instance)
+        .toArray();
+}
+/**
+ * Returns the instances which are not transient
+ * @param instances The instances which should be checked whether they are transient
+ */
+function getNonTransientInstances(instances) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(([key, wrapper]) => wrapper.isDependencyTreeStatic() && !wrapper.isTransient)
+        .map(([key, { instance }]) => instance)
+        .toArray();
+}

package/injector/index.d.ts

@@ -0,0 +1,6 @@
+export * from './container';
+export * from './inquirer';
+export { ContextId, HostComponentInfo } from './instance-wrapper';
+export * from './lazy-module-loader/lazy-module-loader';
+export * from './module-ref';
+export * from './modules-container';

package/injector/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./container"), exports);
+tslib_1.__exportStar(require("./inquirer"), exports);
+tslib_1.__exportStar(require("./lazy-module-loader/lazy-module-loader"), exports);
+tslib_1.__exportStar(require("./module-ref"), exports);
+tslib_1.__exportStar(require("./modules-container"), exports);

package/injector/injector.d.ts

@@ -0,0 +1,104 @@
+import { InjectionToken } from '@nestjs/common';
+import { Controller, ForwardReference, Injectable, Type } from '@nestjs/common/interfaces';
+import { ContextId, InstancePerContext, InstanceWrapper, PropertyMetadata } from './instance-wrapper';
+import { Module } from './module';
+import { SettlementSignal } from './settlement-signal';
+/**
+ * The type of an injectable dependency
+ */
+export type InjectorDependency = InjectionToken;
+/**
+ * The property-based dependency
+ */
+export interface PropertyDependency {
+    key: symbol | string;
+    name: InjectorDependency;
+    isOptional?: boolean;
+    instance?: any;
+}
+/**
+ * Context of a dependency which gets injected by
+ * the injector
+ */
+export interface InjectorDependencyContext {
+    /**
+     * The name of the property key (property-based injection)
+     */
+    key?: string | symbol;
+    /**
+     * The function itself, the name of the function, or injection token.
+     */
+    name?: Function | string | symbol;
+    /**
+     * The index of the dependency which gets injected
+     * from the dependencies array
+     */
+    index?: number;
+    /**
+     * The dependency array which gets injected
+     */
+    dependencies?: InjectorDependency[];
+}
+export declare class Injector {
+    private readonly options?;
+    private logger;
+    private readonly instanceDecorator;
+    constructor(options?: {
+        /**
+         * Whether to enable preview mode.
+         */
+        preview: boolean;
+        /**
+         * Function to decorate a freshly created instance.
+         */
+        instanceDecorator?: (target: unknown) => unknown;
+    } | undefined);
+    loadPrototype<T>({ token }: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper<T>>, contextId?: ContextId): void;
+    loadInstance<T>(wrapper: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadMiddleware(wrapper: InstanceWrapper, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadController(wrapper: InstanceWrapper<Controller>, moduleRef: Module, contextId?: ContextId): Promise<void>;
+    loadInjectable<T = any>(wrapper: InstanceWrapper<T>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadProvider(wrapper: InstanceWrapper<Injectable>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    applySettlementSignal<T>(instancePerContext: InstancePerContext<T>, host: InstanceWrapper<T>): SettlementSignal;
+    resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, moduleRef: Module, inject: InjectorDependency[] | undefined, callback: (args: unknown[]) => void | Promise<void>, contextId?: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<void>;
+    getClassDependencies<T>(wrapper: InstanceWrapper<T>): [InjectorDependency[], number[]];
+    getFactoryProviderDependencies<T>(wrapper: InstanceWrapper<T>): [InjectorDependency[], number[]];
+    reflectConstructorParams<T>(type: Type<T>): any[];
+    reflectOptionalParams<T>(type: Type<T>): any[];
+    reflectSelfParams<T>(type: Type<T>): any[];
+    resolveSingleParam<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol, dependencyContext: InjectorDependencyContext, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<any>>;
+    resolveParamToken<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol | ForwardReference): any;
+    resolveComponentWrapper<T>(moduleRef: Module, token: InjectionToken, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper>;
+    resolveComponentHost<T>(moduleRef: Module, instanceWrapper: InstanceWrapper<T | Promise<T>>, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<InstanceWrapper>;
+    lookupComponent<T = any>(providers: Map<Function | string | symbol, InstanceWrapper>, moduleRef: Module, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<T>>;
+    lookupComponentInParentModules<T = any>(dependencyContext: InjectorDependencyContext, moduleRef: Module, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<any>;
+    lookupComponentInImports(moduleRef: Module, name: InjectionToken, wrapper: InstanceWrapper, moduleRegistry?: Set<string>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number, isTraversing?: boolean): Promise<any>;
+    resolveProperties<T>(wrapper: InstanceWrapper<T>, moduleRef: Module, inject?: InjectorDependency[], contextId?: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<PropertyDependency[]>;
+    reflectProperties<T>(type: Type<T>): PropertyDependency[];
+    applyProperties<T = any>(instance: T, properties: PropertyDependency[]): void;
+    instantiateClass<T = any>(instances: any[], wrapper: InstanceWrapper, targetMetatype: InstanceWrapper, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<T>;
+    loadPerContext<T = any>(instance: T, moduleRef: Module, collection: Map<InjectionToken, InstanceWrapper>, ctx: ContextId, wrapper?: InstanceWrapper): Promise<T>;
+    loadEnhancersPerContext(wrapper: InstanceWrapper, ctx: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadCtorMetadata(metadata: InstanceWrapper<any>[], contextId: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<any[]>;
+    loadPropertiesMetadata(metadata: PropertyMetadata[], contextId: ContextId, inquirer?: InstanceWrapper): Promise<PropertyDependency[]>;
+    private getInquirerId;
+    /**
+     * For nested TRANSIENT dependencies (TRANSIENT -> TRANSIENT) in non-static contexts,
+     * returns parentInquirer to ensure each parent TRANSIENT gets its own instance.
+     * This is necessary because in REQUEST/DURABLE scopes, the same TRANSIENT wrapper
+     * can be used by multiple parents, causing nested TRANSIENTs to be shared incorrectly.
+     * For non-TRANSIENT -> TRANSIENT, returns inquirer (current wrapper being created).
+     */
+    private getEffectiveInquirer;
+    private resolveScopedComponentHost;
+    private isInquirerRequest;
+    private isInquirer;
+    protected addDependencyMetadata(keyOrIndex: symbol | string | number, hostWrapper: InstanceWrapper, instanceWrapper: InstanceWrapper): void;
+    private getTokenName;
+    private printResolvingDependenciesLog;
+    private printLookingForProviderLog;
+    private printFoundInModuleLog;
+    private isDebugMode;
+    private getContextId;
+    private getNowTimestamp;
+}