@depup/nestjs__core 11.1.17-depup.0

package/injector/instance-loader.d.ts

@@ -0,0 +1,23 @@
+import { Logger, LoggerService } from '@nestjs/common';
+import { GraphInspector } from '../inspector/graph-inspector';
+import { NestContainer } from './container';
+import { Injector } from './injector';
+import { Module } from './module';
+export declare class InstanceLoader<TInjector extends Injector = Injector> {
+    protected readonly container: NestContainer;
+    protected readonly injector: TInjector;
+    protected readonly graphInspector: GraphInspector;
+    private logger;
+    constructor(container: NestContainer, injector: TInjector, graphInspector: GraphInspector, logger?: LoggerService);
+    setLogger(logger: Logger): void;
+    createInstancesOfDependencies(modules?: Map<string, Module>): Promise<void>;
+    private createPrototypes;
+    private createInstances;
+    private createPrototypesOfProviders;
+    private createInstancesOfProviders;
+    private createPrototypesOfControllers;
+    private createInstancesOfControllers;
+    private createPrototypesOfInjectables;
+    private createInstancesOfInjectables;
+    private isModuleWhitelisted;
+}

package/injector/instance-loader.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceLoader = void 0;
+const common_1 = require("@nestjs/common");
+const messages_1 = require("../helpers/messages");
+const internal_core_module_1 = require("./internal-core-module/internal-core-module");
+class InstanceLoader {
+    constructor(container, injector, graphInspector, logger = new common_1.Logger(InstanceLoader.name, {
+        timestamp: true,
+    })) {
+        this.container = container;
+        this.injector = injector;
+        this.graphInspector = graphInspector;
+        this.logger = logger;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    async createInstancesOfDependencies(modules = this.container.getModules()) {
+        this.createPrototypes(modules);
+        try {
+            await this.createInstances(modules);
+        }
+        catch (err) {
+            this.graphInspector.inspectModules(modules);
+            this.graphInspector.registerPartial(err);
+            throw err;
+        }
+        this.graphInspector.inspectModules(modules);
+    }
+    createPrototypes(modules) {
+        modules.forEach(moduleRef => {
+            this.createPrototypesOfProviders(moduleRef);
+            this.createPrototypesOfInjectables(moduleRef);
+            this.createPrototypesOfControllers(moduleRef);
+        });
+    }
+    async createInstances(modules) {
+        await Promise.all([...modules.values()].map(async (moduleRef) => {
+            await this.createInstancesOfProviders(moduleRef);
+            await this.createInstancesOfInjectables(moduleRef);
+            await this.createInstancesOfControllers(moduleRef);
+            const { name } = moduleRef;
+            this.isModuleWhitelisted(name) &&
+                this.logger.log((0, messages_1.MODULE_INIT_MESSAGE) `${name}`);
+        }));
+    }
+    createPrototypesOfProviders(moduleRef) {
+        const { providers } = moduleRef;
+        providers.forEach(wrapper => this.injector.loadPrototype(wrapper, providers));
+    }
+    async createInstancesOfProviders(moduleRef) {
+        const { providers } = moduleRef;
+        const wrappers = [...providers.values()];
+        await Promise.all(wrappers.map(async (item) => {
+            await this.injector.loadProvider(item, moduleRef);
+            this.graphInspector.inspectInstanceWrapper(item, moduleRef);
+        }));
+    }
+    createPrototypesOfControllers(moduleRef) {
+        const { controllers } = moduleRef;
+        controllers.forEach(wrapper => this.injector.loadPrototype(wrapper, controllers));
+    }
+    async createInstancesOfControllers(moduleRef) {
+        const { controllers } = moduleRef;
+        const wrappers = [...controllers.values()];
+        await Promise.all(wrappers.map(async (item) => {
+            await this.injector.loadController(item, moduleRef);
+            this.graphInspector.inspectInstanceWrapper(item, moduleRef);
+        }));
+    }
+    createPrototypesOfInjectables(moduleRef) {
+        const { injectables } = moduleRef;
+        injectables.forEach(wrapper => this.injector.loadPrototype(wrapper, injectables));
+    }
+    async createInstancesOfInjectables(moduleRef) {
+        const { injectables } = moduleRef;
+        const wrappers = [...injectables.values()];
+        await Promise.all(wrappers.map(async (item) => {
+            await this.injector.loadInjectable(item, moduleRef);
+            this.graphInspector.inspectInstanceWrapper(item, moduleRef);
+        }));
+    }
+    isModuleWhitelisted(name) {
+        return name !== internal_core_module_1.InternalCoreModule.name;
+    }
+}
+exports.InstanceLoader = InstanceLoader;

package/injector/instance-wrapper.d.ts

@@ -0,0 +1,99 @@
+import { Provider, Scope, Type } from '@nestjs/common';
+import { EnhancerSubtype } from '@nestjs/common/constants';
+import { FactoryProvider, InjectionToken } from '@nestjs/common/interfaces';
+import { Module } from './module';
+import { SettlementSignal } from './settlement-signal';
+export declare const INSTANCE_METADATA_SYMBOL: unique symbol;
+export declare const INSTANCE_ID_SYMBOL: unique symbol;
+export interface HostComponentInfo {
+    /**
+     * Injection token (or class reference)
+     */
+    token: InjectionToken;
+    /**
+     * Flag that indicates whether DI subtree is durable
+     */
+    isTreeDurable: boolean;
+}
+export interface ContextId {
+    readonly id: number;
+    payload?: unknown;
+    getParent?(info: HostComponentInfo): ContextId;
+}
+export interface InstancePerContext<T> {
+    instance: T;
+    isResolved?: boolean;
+    isPending?: boolean;
+    donePromise?: Promise<unknown>;
+    isConstructorCalled?: boolean;
+}
+export interface PropertyMetadata {
+    key: symbol | string;
+    wrapper: InstanceWrapper;
+}
+export declare class InstanceWrapper<T = any> {
+    readonly name: any;
+    readonly token: InjectionToken;
+    readonly async?: boolean;
+    readonly host?: Module;
+    readonly isAlias: boolean;
+    readonly subtype?: EnhancerSubtype;
+    scope?: Scope;
+    metatype: Type<T> | Function | null;
+    inject?: FactoryProvider['inject'] | null;
+    forwardRef?: boolean;
+    durable?: boolean;
+    initTime?: number;
+    settlementSignal?: SettlementSignal;
+    private static logger;
+    private readonly values;
+    private readonly [INSTANCE_METADATA_SYMBOL];
+    private readonly [INSTANCE_ID_SYMBOL];
+    private transientMap?;
+    private isTreeStatic;
+    private isTreeDurable;
+    /**
+     * The root inquirer reference. Present only if child instance wrapper
+     * is transient and has a parent inquirer.
+     */
+    private rootInquirer;
+    constructor(metadata?: Partial<InstanceWrapper<T>> & Partial<InstancePerContext<T>>);
+    get id(): string;
+    set instance(value: T);
+    get instance(): T;
+    get isNotMetatype(): boolean;
+    get isFactory(): boolean;
+    get isTransient(): boolean;
+    getInstanceByContextId(contextId: ContextId, inquirerId?: string): InstancePerContext<T>;
+    getInstanceByInquirerId(contextId: ContextId, inquirerId: string): InstancePerContext<T>;
+    setInstanceByContextId(contextId: ContextId, value: InstancePerContext<T>, inquirerId?: string): void;
+    setInstanceByInquirerId(contextId: ContextId, inquirerId: string, value: InstancePerContext<T>): void;
+    removeInstanceByContextId(contextId: ContextId, inquirerId?: string): void;
+    removeInstanceByInquirerId(contextId: ContextId, inquirerId: string): void;
+    addCtorMetadata(index: number, wrapper: InstanceWrapper): void;
+    getCtorMetadata(): InstanceWrapper[];
+    addPropertiesMetadata(key: symbol | string, wrapper: InstanceWrapper): void;
+    getPropertiesMetadata(): PropertyMetadata[];
+    addEnhancerMetadata(wrapper: InstanceWrapper): void;
+    getEnhancersMetadata(): InstanceWrapper[];
+    isDependencyTreeDurable(lookupRegistry?: string[]): boolean;
+    introspectDepsAttribute(callback: (collection: InstanceWrapper[], lookupRegistry: string[]) => boolean, lookupRegistry?: string[]): boolean;
+    isDependencyTreeStatic(lookupRegistry?: string[]): boolean;
+    cloneStaticInstance(contextId: ContextId): InstancePerContext<T>;
+    cloneTransientInstance(contextId: ContextId, inquirerId: string): InstancePerContext<T>;
+    createPrototype(contextId: ContextId): any;
+    isInRequestScope(contextId: ContextId, inquirer?: InstanceWrapper): boolean;
+    isLazyTransient(contextId: ContextId, inquirer: InstanceWrapper | undefined): boolean;
+    isExplicitlyRequested(contextId: ContextId, inquirer?: InstanceWrapper): boolean;
+    isStatic(contextId: ContextId, inquirer: InstanceWrapper | undefined): boolean;
+    attachRootInquirer(inquirer: InstanceWrapper): void;
+    getRootInquirer(): InstanceWrapper | undefined;
+    getStaticTransientInstances(): (InstancePerContext<T> | undefined)[];
+    mergeWith(provider: Provider): void;
+    private isNewable;
+    private initialize;
+    private printIntrospectedAsRequestScoped;
+    private printIntrospectedAsDurable;
+    private isDebugMode;
+    private generateUuid;
+}

package/injector/instance-wrapper.js

@@ -0,0 +1,350 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceWrapper = exports.INSTANCE_ID_SYMBOL = exports.INSTANCE_METADATA_SYMBOL = void 0;
+const common_1 = require("@nestjs/common");
+const cli_colors_util_1 = require("@nestjs/common/utils/cli-colors.util");
+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 uuid_factory_1 = require("../inspector/uuid-factory");
+const constants_1 = require("./constants");
+const provider_classifier_1 = require("./helpers/provider-classifier");
+exports.INSTANCE_METADATA_SYMBOL = Symbol.for('instance_metadata:cache');
+exports.INSTANCE_ID_SYMBOL = Symbol.for('instance_metadata:id');
+class InstanceWrapper {
+    constructor(metadata = {}) {
+        this.isAlias = false;
+        this.scope = common_1.Scope.DEFAULT;
+        this.values = new WeakMap();
+        this[_a] = {};
+        this.initialize(metadata);
+        this[exports.INSTANCE_ID_SYMBOL] =
+            metadata[exports.INSTANCE_ID_SYMBOL] ?? this.generateUuid();
+    }
+    get id() {
+        return this[exports.INSTANCE_ID_SYMBOL];
+    }
+    set instance(value) {
+        this.values.set(constants_1.STATIC_CONTEXT, { instance: value });
+    }
+    get instance() {
+        const instancePerContext = this.getInstanceByContextId(constants_1.STATIC_CONTEXT);
+        return instancePerContext.instance;
+    }
+    get isNotMetatype() {
+        return !this.metatype || this.isFactory;
+    }
+    get isFactory() {
+        return !!this.metatype && !(0, shared_utils_1.isNil)(this.inject);
+    }
+    get isTransient() {
+        return this.scope === common_1.Scope.TRANSIENT;
+    }
+    getInstanceByContextId(contextId, inquirerId) {
+        if (this.scope === common_1.Scope.TRANSIENT && inquirerId) {
+            return this.getInstanceByInquirerId(contextId, inquirerId);
+        }
+        const instancePerContext = this.values.get(contextId);
+        return instancePerContext
+            ? instancePerContext
+            : contextId !== constants_1.STATIC_CONTEXT
+                ? this.cloneStaticInstance(contextId)
+                : {
+                    instance: null,
+                    isResolved: true,
+                    isPending: false,
+                };
+    }
+    getInstanceByInquirerId(contextId, inquirerId) {
+        let collectionPerContext = this.transientMap.get(inquirerId);
+        if (!collectionPerContext) {
+            collectionPerContext = new WeakMap();
+            this.transientMap.set(inquirerId, collectionPerContext);
+        }
+        const instancePerContext = collectionPerContext.get(contextId);
+        return instancePerContext
+            ? instancePerContext
+            : this.cloneTransientInstance(contextId, inquirerId);
+    }
+    setInstanceByContextId(contextId, value, inquirerId) {
+        if (this.scope === common_1.Scope.TRANSIENT && inquirerId) {
+            return this.setInstanceByInquirerId(contextId, inquirerId, value);
+        }
+        this.values.set(contextId, value);
+    }
+    setInstanceByInquirerId(contextId, inquirerId, value) {
+        let collection = this.transientMap.get(inquirerId);
+        if (!collection) {
+            collection = new WeakMap();
+            this.transientMap.set(inquirerId, collection);
+        }
+        collection.set(contextId, value);
+    }
+    removeInstanceByContextId(contextId, inquirerId) {
+        if (this.scope === common_1.Scope.TRANSIENT && inquirerId) {
+            return this.removeInstanceByInquirerId(contextId, inquirerId);
+        }
+        this.values.delete(contextId);
+    }
+    removeInstanceByInquirerId(contextId, inquirerId) {
+        const collection = this.transientMap.get(inquirerId);
+        if (!collection) {
+            return;
+        }
+        collection.delete(contextId);
+    }
+    addCtorMetadata(index, wrapper) {
+        if (!this[exports.INSTANCE_METADATA_SYMBOL].dependencies) {
+            this[exports.INSTANCE_METADATA_SYMBOL].dependencies = [];
+        }
+        this[exports.INSTANCE_METADATA_SYMBOL].dependencies[index] = wrapper;
+    }
+    getCtorMetadata() {
+        return this[exports.INSTANCE_METADATA_SYMBOL].dependencies;
+    }
+    addPropertiesMetadata(key, wrapper) {
+        if (!this[exports.INSTANCE_METADATA_SYMBOL].properties) {
+            this[exports.INSTANCE_METADATA_SYMBOL].properties = [];
+        }
+        this[exports.INSTANCE_METADATA_SYMBOL].properties.push({
+            key,
+            wrapper,
+        });
+    }
+    getPropertiesMetadata() {
+        return this[exports.INSTANCE_METADATA_SYMBOL].properties;
+    }
+    addEnhancerMetadata(wrapper) {
+        if (!this[exports.INSTANCE_METADATA_SYMBOL].enhancers) {
+            this[exports.INSTANCE_METADATA_SYMBOL].enhancers = [];
+        }
+        this[exports.INSTANCE_METADATA_SYMBOL].enhancers.push(wrapper);
+    }
+    getEnhancersMetadata() {
+        return this[exports.INSTANCE_METADATA_SYMBOL].enhancers;
+    }
+    isDependencyTreeDurable(lookupRegistry = []) {
+        if (!(0, shared_utils_1.isUndefined)(this.isTreeDurable)) {
+            return this.isTreeDurable;
+        }
+        if (this.scope === common_1.Scope.REQUEST) {
+            this.isTreeDurable = this.durable === undefined ? false : this.durable;
+            if (this.isTreeDurable) {
+                this.printIntrospectedAsDurable();
+            }
+            return this.isTreeDurable;
+        }
+        const isStatic = this.isDependencyTreeStatic();
+        if (isStatic) {
+            return false;
+        }
+        const isTreeNonDurable = this.introspectDepsAttribute((collection, registry) => collection.some((item) => !item.isDependencyTreeStatic() &&
+            !item.isDependencyTreeDurable(registry)), lookupRegistry);
+        this.isTreeDurable = !isTreeNonDurable;
+        if (this.isTreeDurable) {
+            this.printIntrospectedAsDurable();
+        }
+        return this.isTreeDurable;
+    }
+    introspectDepsAttribute(callback, lookupRegistry = []) {
+        if (lookupRegistry.includes(this[exports.INSTANCE_ID_SYMBOL])) {
+            return false;
+        }
+        lookupRegistry = lookupRegistry.concat(this[exports.INSTANCE_ID_SYMBOL]);
+        const { dependencies, properties, enhancers } = this[exports.INSTANCE_METADATA_SYMBOL];
+        let introspectionResult = dependencies
+            ? callback(dependencies, lookupRegistry)
+            : false;
+        if (introspectionResult || !(properties || enhancers)) {
+            return introspectionResult;
+        }
+        introspectionResult = properties
+            ? callback(properties.map(item => item.wrapper), lookupRegistry)
+            : false;
+        if (introspectionResult || !enhancers) {
+            return introspectionResult;
+        }
+        return enhancers ? callback(enhancers, lookupRegistry) : false;
+    }
+    isDependencyTreeStatic(lookupRegistry = []) {
+        if (!(0, shared_utils_1.isUndefined)(this.isTreeStatic)) {
+            return this.isTreeStatic;
+        }
+        if (this.scope === common_1.Scope.REQUEST) {
+            this.isTreeStatic = false;
+            this.printIntrospectedAsRequestScoped();
+            return this.isTreeStatic;
+        }
+        this.isTreeStatic = !this.introspectDepsAttribute((collection, registry) => collection.some((item) => !item.isDependencyTreeStatic(registry)), lookupRegistry);
+        if (!this.isTreeStatic) {
+            this.printIntrospectedAsRequestScoped();
+        }
+        return this.isTreeStatic;
+    }
+    cloneStaticInstance(contextId) {
+        const staticInstance = this.getInstanceByContextId(constants_1.STATIC_CONTEXT);
+        if (this.isDependencyTreeStatic()) {
+            return staticInstance;
+        }
+        const instancePerContext = {
+            ...staticInstance,
+            instance: undefined,
+            isResolved: false,
+            isPending: false,
+        };
+        if (this.isNewable()) {
+            instancePerContext.instance = Object.create(this.metatype.prototype);
+        }
+        this.setInstanceByContextId(contextId, instancePerContext);
+        return instancePerContext;
+    }
+    cloneTransientInstance(contextId, inquirerId) {
+        const staticInstance = this.getInstanceByContextId(constants_1.STATIC_CONTEXT);
+        const instancePerContext = {
+            ...staticInstance,
+            instance: undefined,
+            isResolved: false,
+            isPending: false,
+        };
+        if (this.isNewable()) {
+            instancePerContext.instance = Object.create(this.metatype.prototype);
+        }
+        this.setInstanceByInquirerId(contextId, inquirerId, instancePerContext);
+        return instancePerContext;
+    }
+    createPrototype(contextId) {
+        const host = this.getInstanceByContextId(contextId);
+        if (!this.isNewable() || host.isResolved) {
+            return;
+        }
+        return Object.create(this.metatype.prototype);
+    }
+    isInRequestScope(contextId, inquirer) {
+        const isDependencyTreeStatic = this.isDependencyTreeStatic();
+        return (!isDependencyTreeStatic &&
+            contextId !== constants_1.STATIC_CONTEXT &&
+            (!this.isTransient || (this.isTransient && !!inquirer)));
+    }
+    isLazyTransient(contextId, inquirer) {
+        const isInquirerRequestScoped = !!(inquirer && !inquirer.isDependencyTreeStatic());
+        return (this.isDependencyTreeStatic() &&
+            contextId !== constants_1.STATIC_CONTEXT &&
+            this.isTransient &&
+            isInquirerRequestScoped);
+    }
+    isExplicitlyRequested(contextId, inquirer) {
+        const isSelfRequested = inquirer === this;
+        return (this.isDependencyTreeStatic() &&
+            contextId !== constants_1.STATIC_CONTEXT &&
+            (isSelfRequested || !!(inquirer && inquirer.scope === common_1.Scope.TRANSIENT)));
+    }
+    isStatic(contextId, inquirer) {
+        if (!this.isDependencyTreeStatic() || contextId !== constants_1.STATIC_CONTEXT) {
+            return false;
+        }
+        // Non-transient provider in static context
+        if (!this.isTransient) {
+            return true;
+        }
+        const isInquirerRequestScoped = inquirer && !inquirer.isDependencyTreeStatic();
+        const isStaticTransient = this.isTransient && !isInquirerRequestScoped;
+        const rootInquirer = inquirer?.getRootInquirer();
+        // Transient provider inquired by non-transient (e.g., DEFAULT -> TRANSIENT)
+        if (isStaticTransient && inquirer && !inquirer.isTransient) {
+            return true;
+        }
+        // Nested transient with non-transient root (e.g., DEFAULT -> TRANSIENT -> TRANSIENT)
+        if (isStaticTransient && rootInquirer && !rootInquirer.isTransient) {
+            return true;
+        }
+        // Nested transient during initial instantiation (rootInquirer not yet set)
+        if (isStaticTransient && inquirer?.isTransient && !rootInquirer) {
+            return true;
+        }
+        return false;
+    }
+    attachRootInquirer(inquirer) {
+        if (!this.isTransient) {
+            // Only attach root inquirer if the instance wrapper is transient
+            return;
+        }
+        this.rootInquirer = inquirer.getRootInquirer() ?? inquirer;
+    }
+    getRootInquirer() {
+        return this.rootInquirer;
+    }
+    getStaticTransientInstances() {
+        if (!this.transientMap) {
+            return [];
+        }
+        const instances = [...this.transientMap.values()];
+        return (0, iterare_1.iterate)(instances)
+            .map(item => item.get(constants_1.STATIC_CONTEXT))
+            .filter(item => {
+            // Only return items where constructor has been actually called
+            // This prevents calling lifecycle hooks on non-instantiated transient services
+            return !!(item && item.isConstructorCalled);
+        })
+            .toArray();
+    }
+    mergeWith(provider) {
+        if ((0, provider_classifier_1.isValueProvider)(provider)) {
+            this.metatype = null;
+            this.inject = null;
+            this.scope = common_1.Scope.DEFAULT;
+            this.setInstanceByContextId(constants_1.STATIC_CONTEXT, {
+                instance: provider.useValue,
+                isResolved: true,
+                isPending: false,
+            });
+        }
+        else if ((0, provider_classifier_1.isClassProvider)(provider)) {
+            this.inject = null;
+            this.metatype = provider.useClass;
+        }
+        else if ((0, provider_classifier_1.isFactoryProvider)(provider)) {
+            this.metatype = provider.useFactory;
+            this.inject = provider.inject || [];
+        }
+    }
+    isNewable() {
+        return (0, shared_utils_1.isNil)(this.inject) && this.metatype && this.metatype.prototype;
+    }
+    initialize(metadata) {
+        const { instance, isResolved, ...wrapperPartial } = metadata;
+        Object.assign(this, wrapperPartial);
+        this.setInstanceByContextId(constants_1.STATIC_CONTEXT, {
+            instance: instance,
+            isResolved,
+        });
+        this.scope === common_1.Scope.TRANSIENT && (this.transientMap = new Map());
+    }
+    printIntrospectedAsRequestScoped() {
+        if (!this.isDebugMode() || this.name === 'REQUEST') {
+            return;
+        }
+        if ((0, shared_utils_1.isString)(this.name)) {
+            InstanceWrapper.logger.log(`${cli_colors_util_1.clc.cyanBright(this.name)}${cli_colors_util_1.clc.green(' introspected as ')}${cli_colors_util_1.clc.magentaBright('request-scoped')}`);
+        }
+    }
+    printIntrospectedAsDurable() {
+        if (!this.isDebugMode()) {
+            return;
+        }
+        if ((0, shared_utils_1.isString)(this.name)) {
+            InstanceWrapper.logger.log(`${cli_colors_util_1.clc.cyanBright(this.name)}${cli_colors_util_1.clc.green(' introspected as ')}${cli_colors_util_1.clc.magentaBright('durable')}`);
+        }
+    }
+    isDebugMode() {
+        return !!process.env.NEST_DEBUG;
+    }
+    generateUuid() {
+        let key = this.name?.toString() ?? this.token?.toString();
+        key += this.host?.name ?? '';
+        return key ? uuid_factory_1.UuidFactory.get(key) : (0, random_string_generator_util_1.randomStringGenerator)();
+    }
+}
+exports.InstanceWrapper = InstanceWrapper;
+_a = exports.INSTANCE_METADATA_SYMBOL;
+InstanceWrapper.logger = new common_1.Logger(InstanceWrapper.name);

package/injector/internal-core-module/index.d.ts

@@ -0,0 +1 @@
+export * from './internal-core-module';

package/injector/internal-core-module/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./internal-core-module"), exports);

package/injector/internal-core-module/internal-core-module-factory.d.ts

@@ -0,0 +1,9 @@
+import { HttpAdapterHost } from '../../helpers/http-adapter-host';
+import { GraphInspector } from '../../inspector/graph-inspector';
+import { ModuleOverride } from '../../interfaces/module-override.interface';
+import { DependenciesScanner } from '../../scanner';
+import { ModuleCompiler } from '../compiler';
+import { NestContainer } from '../container';
+export declare class InternalCoreModuleFactory {
+    static create(container: NestContainer, scanner: DependenciesScanner, moduleCompiler: ModuleCompiler, httpAdapterHost: HttpAdapterHost, graphInspector: GraphInspector, moduleOverrides?: ModuleOverride[]): import("@nestjs/common").DynamicModule;
+}

package/injector/internal-core-module/internal-core-module-factory.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalCoreModuleFactory = void 0;
+const common_1 = require("@nestjs/common");
+const external_context_creator_1 = require("../../helpers/external-context-creator");
+const http_adapter_host_1 = require("../../helpers/http-adapter-host");
+const initialize_on_preview_allowlist_1 = require("../../inspector/initialize-on-preview.allowlist");
+const serialized_graph_1 = require("../../inspector/serialized-graph");
+const injector_1 = require("../injector");
+const instance_loader_1 = require("../instance-loader");
+const lazy_module_loader_1 = require("../lazy-module-loader/lazy-module-loader");
+const modules_container_1 = require("../modules-container");
+const internal_core_module_1 = require("./internal-core-module");
+class InternalCoreModuleFactory {
+    static create(container, scanner, moduleCompiler, httpAdapterHost, graphInspector, moduleOverrides) {
+        const lazyModuleLoaderFactory = () => {
+            const logger = new common_1.Logger(lazy_module_loader_1.LazyModuleLoader.name, {
+                timestamp: false,
+            });
+            const injector = new injector_1.Injector({
+                preview: container.contextOptions?.preview,
+                instanceDecorator: container.contextOptions?.instrument?.instanceDecorator,
+            });
+            const instanceLoader = new instance_loader_1.InstanceLoader(container, injector, graphInspector, logger);
+            return new lazy_module_loader_1.LazyModuleLoader(scanner, instanceLoader, moduleCompiler, container.getModules(), moduleOverrides);
+        };
+        initialize_on_preview_allowlist_1.InitializeOnPreviewAllowlist.add(internal_core_module_1.InternalCoreModule);
+        return internal_core_module_1.InternalCoreModule.register([
+            {
+                provide: external_context_creator_1.ExternalContextCreator,
+                useFactory: () => external_context_creator_1.ExternalContextCreator.fromContainer(container),
+            },
+            {
+                provide: modules_container_1.ModulesContainer,
+                useFactory: () => container.getModules(),
+            },
+            {
+                provide: http_adapter_host_1.HttpAdapterHost,
+                useFactory: () => httpAdapterHost,
+            },
+            {
+                provide: lazy_module_loader_1.LazyModuleLoader,
+                useFactory: lazyModuleLoaderFactory,
+            },
+            {
+                provide: serialized_graph_1.SerializedGraph,
+                useFactory: () => container.serializedGraph,
+            },
+        ]);
+    }
+}
+exports.InternalCoreModuleFactory = InternalCoreModuleFactory;

package/injector/internal-core-module/internal-core-module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+import { ExistingProvider, FactoryProvider, ValueProvider } from '@nestjs/common/interfaces';
+export declare class InternalCoreModule {
+    static register(providers: Array<ValueProvider | FactoryProvider | ExistingProvider>): DynamicModule;
+}

package/injector/internal-core-module/internal-core-module.js

@@ -0,0 +1,40 @@
+"use strict";
+var InternalCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalCoreModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const request_providers_1 = require("../../router/request/request-providers");
+const services_1 = require("../../services");
+const inquirer_providers_1 = require("../inquirer/inquirer-providers");
+const ReflectorAliasProvider = {
+    provide: services_1.Reflector.name,
+    useExisting: services_1.Reflector,
+};
+let InternalCoreModule = InternalCoreModule_1 = class InternalCoreModule {
+    static register(providers) {
+        return {
+            module: InternalCoreModule_1,
+            providers: [...providers],
+            exports: [...providers.map(item => item.provide)],
+        };
+    }
+};
+exports.InternalCoreModule = InternalCoreModule;
+exports.InternalCoreModule = InternalCoreModule = InternalCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [
+            services_1.Reflector,
+            ReflectorAliasProvider,
+            request_providers_1.requestProvider,
+            inquirer_providers_1.inquirerProvider,
+        ],
+        exports: [
+            services_1.Reflector,
+            ReflectorAliasProvider,
+            request_providers_1.requestProvider,
+            inquirer_providers_1.inquirerProvider,
+        ],
+    })
+], InternalCoreModule);