@depup/nestjs__core 11.1.17-depup.0

package/injector/internal-providers-storage.d.ts

@@ -0,0 +1,9 @@
+import { AbstractHttpAdapter } from '../adapters';
+import { HttpAdapterHost } from '../helpers/http-adapter-host';
+export declare class InternalProvidersStorage {
+    private readonly _httpAdapterHost;
+    private _httpAdapter;
+    get httpAdapterHost(): HttpAdapterHost;
+    get httpAdapter(): AbstractHttpAdapter;
+    set httpAdapter(httpAdapter: AbstractHttpAdapter);
+}

package/injector/internal-providers-storage.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalProvidersStorage = void 0;
+const http_adapter_host_1 = require("../helpers/http-adapter-host");
+class InternalProvidersStorage {
+    constructor() {
+        this._httpAdapterHost = new http_adapter_host_1.HttpAdapterHost();
+    }
+    get httpAdapterHost() {
+        return this._httpAdapterHost;
+    }
+    get httpAdapter() {
+        return this._httpAdapter;
+    }
+    set httpAdapter(httpAdapter) {
+        this._httpAdapter = httpAdapter;
+    }
+}
+exports.InternalProvidersStorage = InternalProvidersStorage;

package/injector/lazy-module-loader/lazy-module-loader-options.interface.d.ts

@@ -0,0 +1,6 @@
+export interface LazyModuleLoaderLoadOptions {
+    /**
+     * If `false`, no logs will be generated when loading some module lazily.
+     */
+    logger?: boolean;
+}

package/injector/lazy-module-loader/lazy-module-loader-options.interface.js

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

package/injector/lazy-module-loader/lazy-module-loader.d.ts

@@ -0,0 +1,20 @@
+import { DynamicModule, Type } from '@nestjs/common';
+import { ModuleOverride } from '../../interfaces/module-override.interface';
+import { DependenciesScanner } from '../../scanner';
+import { ModuleCompiler } from '../compiler';
+import { InstanceLoader } from '../instance-loader';
+import { ModuleRef } from '../module-ref';
+import { ModulesContainer } from '../modules-container';
+import { LazyModuleLoaderLoadOptions } from './lazy-module-loader-options.interface';
+export declare class LazyModuleLoader {
+    private readonly dependenciesScanner;
+    private readonly instanceLoader;
+    private readonly moduleCompiler;
+    private readonly modulesContainer;
+    private readonly moduleOverrides?;
+    constructor(dependenciesScanner: DependenciesScanner, instanceLoader: InstanceLoader, moduleCompiler: ModuleCompiler, modulesContainer: ModulesContainer, moduleOverrides?: ModuleOverride[] | undefined);
+    load(loaderFn: () => Promise<Type<unknown> | DynamicModule> | Type<unknown> | DynamicModule, loadOpts?: LazyModuleLoaderLoadOptions): Promise<ModuleRef>;
+    private registerLoggerConfiguration;
+    private createLazyModulesContainer;
+    private getTargetModuleRef;
+}

package/injector/lazy-module-loader/lazy-module-loader.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyModuleLoader = void 0;
+const silent_logger_1 = require("../helpers/silent-logger");
+const module_ref_1 = require("../module-ref");
+class LazyModuleLoader {
+    constructor(dependenciesScanner, instanceLoader, moduleCompiler, modulesContainer, moduleOverrides) {
+        this.dependenciesScanner = dependenciesScanner;
+        this.instanceLoader = instanceLoader;
+        this.moduleCompiler = moduleCompiler;
+        this.modulesContainer = modulesContainer;
+        this.moduleOverrides = moduleOverrides;
+    }
+    async load(loaderFn, loadOpts) {
+        this.registerLoggerConfiguration(loadOpts);
+        const moduleClassOrDynamicDefinition = await loaderFn();
+        const moduleInstances = await this.dependenciesScanner.scanForModules({
+            moduleDefinition: moduleClassOrDynamicDefinition,
+            overrides: this.moduleOverrides,
+            lazy: true,
+        });
+        if (moduleInstances.length === 0) {
+            // The module has been loaded already. In this case, we must
+            // retrieve a module reference from the existing container.
+            const { token } = await this.moduleCompiler.compile(moduleClassOrDynamicDefinition);
+            const moduleInstance = this.modulesContainer.get(token);
+            return moduleInstance && this.getTargetModuleRef(moduleInstance);
+        }
+        const lazyModulesContainer = this.createLazyModulesContainer(moduleInstances);
+        await this.dependenciesScanner.scanModulesForDependencies(lazyModulesContainer);
+        await this.instanceLoader.createInstancesOfDependencies(lazyModulesContainer);
+        const [targetModule] = moduleInstances;
+        return this.getTargetModuleRef(targetModule);
+    }
+    registerLoggerConfiguration(loadOpts) {
+        if (loadOpts?.logger === false) {
+            this.instanceLoader.setLogger(new silent_logger_1.SilentLogger());
+        }
+    }
+    createLazyModulesContainer(moduleInstances) {
+        moduleInstances = Array.from(new Set(moduleInstances));
+        return new Map(moduleInstances.map(ref => [ref.token, ref]));
+    }
+    getTargetModuleRef(moduleInstance) {
+        const moduleRefInstanceWrapper = moduleInstance.getProviderByKey(module_ref_1.ModuleRef);
+        return moduleRefInstanceWrapper.instance;
+    }
+}
+exports.LazyModuleLoader = LazyModuleLoader;

package/injector/module-ref.d.ts

@@ -0,0 +1,106 @@
+import { IntrospectionResult, Type } from '@nestjs/common';
+import { AbstractInstanceResolver } from './abstract-instance-resolver';
+import { NestContainer } from './container';
+import { Injector } from './injector';
+import { InstanceLinksHost } from './instance-links-host';
+import { ContextId } from './instance-wrapper';
+import { Module } from './module';
+export interface ModuleRefGetOrResolveOpts {
+    /**
+     * If enabled, lookup will only be performed in the host module.
+     * @default true
+     */
+    strict?: boolean;
+    /**
+     * If enabled, instead of returning a first instance registered under a given token,
+     * a list of instances will be returned.
+     * @default false
+     */
+    each?: boolean;
+}
+export declare abstract class ModuleRef extends AbstractInstanceResolver {
+    protected readonly container: NestContainer;
+    protected readonly injector: Injector;
+    private _instanceLinksHost;
+    protected get instanceLinksHost(): InstanceLinksHost;
+    constructor(container: NestContainer);
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): TResult;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        /**
+         * If enabled, lookup will only be performed in the host module.
+         * @default true
+         */
+        strict?: boolean;
+        /** This indicates that only the first instance registered will be returned. */
+        each?: undefined | false;
+    }): TResult;
+    /**
+     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        /**
+         * If enabled, lookup will only be performed in the host module.
+         * @default true
+         */
+        strict?: boolean;
+        /** This indicates that a list of instances will be returned. */
+        each: true;
+    }): Array<TResult>;
+    /**
+     * Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult | Array<TResult>}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: ModuleRefGetOrResolveOpts): TResult | Array<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each?: undefined | false;
+    }): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each: true;
+    }): Promise<Array<TResult>>;
+    /**
+     * Resolves transient or request-scoped instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {Promise<TResult | Array<TResult>>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: ModuleRefGetOrResolveOpts): Promise<TResult | Array<TResult>>;
+    abstract create<T = any>(type: Type<T>, contextId?: ContextId): Promise<T>;
+    introspect<T = any>(token: Type<T> | string | symbol): IntrospectionResult;
+    registerRequestByContextId<T = any>(request: T, contextId: ContextId): void;
+    protected instantiateClass<T = any>(type: Type<T>, moduleRef: Module, contextId?: ContextId): Promise<T>;
+}

package/injector/module-ref.js

@@ -0,0 +1,66 @@
+"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 {
+    get instanceLinksHost() {
+        if (!this._instanceLinksHost) {
+            this._instanceLinksHost = new instance_links_host_1.InstanceLinksHost(this.container);
+        }
+        return this._instanceLinksHost;
+    }
+    constructor(container) {
+        super();
+        this.container = container;
+        this.injector = new injector_1.Injector({
+            preview: container.contextOptions?.preview,
+            instanceDecorator: container.contextOptions?.instrument?.instanceDecorator,
+        });
+    }
+    introspect(token) {
+        const { wrapperRef } = this.instanceLinksHost.get(token);
+        let scope = common_1.Scope.DEFAULT;
+        if (!wrapperRef.isDependencyTreeStatic()) {
+            scope = common_1.Scope.REQUEST;
+        }
+        else if (wrapperRef.isTransient) {
+            scope = common_1.Scope.TRANSIENT;
+        }
+        return { scope };
+    }
+    registerRequestByContextId(request, contextId) {
+        this.container.registerRequestProvider(request, contextId);
+    }
+    async instantiateClass(type, moduleRef, contextId) {
+        const wrapper = new instance_wrapper_1.InstanceWrapper({
+            name: type && type.name,
+            metatype: type,
+            isResolved: false,
+            scope: (0, get_class_scope_1.getClassScope)(type),
+            durable: (0, is_durable_1.isDurable)(type),
+            host: moduleRef,
+        });
+        /* eslint-disable-next-line no-async-promise-executor */
+        return new Promise(async (resolve, reject) => {
+            try {
+                const callback = async (instances) => {
+                    const properties = await this.injector.resolveProperties(wrapper, moduleRef, undefined, contextId);
+                    const instance = new type(...instances);
+                    this.injector.applyProperties(instance, properties);
+                    resolve(instance);
+                };
+                await this.injector.resolveConstructorParams(wrapper, moduleRef, undefined, callback, contextId);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+}
+exports.ModuleRef = ModuleRef;

package/injector/module.d.ts

@@ -0,0 +1,82 @@
+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';
+export declare class Module {
+    private readonly _metatype;
+    private readonly container;
+    private readonly _id;
+    private readonly _imports;
+    private readonly _providers;
+    private readonly _injectables;
+    private readonly _middlewares;
+    private readonly _controllers;
+    private readonly _entryProviderKeys;
+    private readonly _exports;
+    private _distance;
+    private _initOnPreview;
+    private _isGlobal;
+    private _token;
+    constructor(_metatype: Type<any>, container: NestContainer);
+    get id(): string;
+    get token(): string;
+    set token(token: string);
+    get name(): string;
+    get isGlobal(): boolean;
+    set isGlobal(global: boolean);
+    get initOnPreview(): boolean;
+    set initOnPreview(initOnPreview: boolean);
+    get providers(): Map<InjectionToken, InstanceWrapper<Injectable>>;
+    get middlewares(): Map<InjectionToken, InstanceWrapper<Injectable>>;
+    get imports(): Set<Module>;
+    get injectables(): Map<InjectionToken, InstanceWrapper<Injectable>>;
+    get controllers(): Map<InjectionToken, InstanceWrapper<Controller>>;
+    get entryProviders(): Array<InstanceWrapper<Injectable>>;
+    get exports(): Set<InjectionToken>;
+    get instance(): NestModule;
+    get metatype(): Type<any>;
+    get distance(): number;
+    set distance(value: number);
+    addCoreProviders(): void;
+    addModuleRef(): void;
+    addModuleAsProvider(): void;
+    addApplicationConfig(): void;
+    addInjectable<T extends Injectable>(injectable: Provider, enhancerSubtype: EnhancerSubtype, host?: Type<T>): string | symbol | Function | InstanceWrapper<unknown>;
+    addProvider(provider: Provider): InjectionToken;
+    addProvider(provider: Provider, enhancerSubtype: EnhancerSubtype): InjectionToken;
+    isCustomProvider(provider: Provider): provider is ClassProvider | FactoryProvider | ValueProvider | ExistingProvider;
+    addCustomProvider(provider: ClassProvider | FactoryProvider | ValueProvider | ExistingProvider, collection: Map<Function | string | symbol, any>, enhancerSubtype?: EnhancerSubtype): InjectionToken;
+    isCustomClass(provider: any): provider is ClassProvider;
+    isCustomValue(provider: any): provider is ValueProvider;
+    isCustomFactory(provider: any): provider is FactoryProvider;
+    isCustomUseExisting(provider: any): provider is ExistingProvider;
+    isDynamicModule(exported: any): exported is DynamicModule;
+    addCustomClass(provider: ClassProvider, collection: Map<InjectionToken, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
+    addCustomValue(provider: ValueProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
+    addCustomFactory(provider: FactoryProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
+    addCustomUseExisting(provider: ExistingProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
+    addExportedProviderOrModule(toExport: Provider | string | symbol | DynamicModule): Set<InjectionToken> | undefined;
+    addCustomExportedProvider(provider: FactoryProvider | ValueProvider | ClassProvider | ExistingProvider): Set<InjectionToken> | undefined;
+    validateExportedProvider(token: InjectionToken): InjectionToken;
+    addController(controller: Type<Controller>): void;
+    assignControllerUniqueId(controller: Type<Controller>): void;
+    addImport(moduleRef: Module): void;
+    replace(toReplace: InjectionToken, options: any): void;
+    hasProvider(token: InjectionToken): boolean;
+    hasInjectable(token: InjectionToken): boolean;
+    getProviderByKey<T = any>(name: InjectionToken<T>): InstanceWrapper<T>;
+    getProviderById<T = any>(id: string): InstanceWrapper<T> | undefined;
+    getControllerById<T = any>(id: string): InstanceWrapper<T> | undefined;
+    getInjectableById<T = any>(id: string): InstanceWrapper<T> | undefined;
+    getMiddlewareById<T = any>(id: string): InstanceWrapper<T> | undefined;
+    getNonAliasProviders(): Array<[
+        InjectionToken,
+        InstanceWrapper<Injectable>
+    ]>;
+    createModuleReferenceType(): Type<ModuleRef>;
+    private isEntryProvider;
+    private generateUuid;
+    private isTransientProvider;
+    private isRequestScopeProvider;
+}