@venok/core 1.0.0

package/injector/instance/loader.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceLoader = void 0;
+const logger_service_1 = require("@venok/core/services/logger.service");
+const internal_core_module_1 = require("@venok/core/injector/internal-core-module/internal-core-module");
+const messages_helper_1 = require("@venok/core/helpers/messages.helper");
+class InstanceLoader {
+    constructor(container, injector, graphInspector, logger = new logger_service_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);
+        });
+    }
+    async createInstances(modules) {
+        await Promise.all([...modules.values()].map(async (moduleRef) => {
+            await this.createInstancesOfProviders(moduleRef);
+            await this.createInstancesOfInjectables(moduleRef);
+            const { name } = moduleRef;
+            this.isModuleWhitelisted(name) && this.logger.log((0, messages_helper_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);
+        }));
+    }
+    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/resolver.d.ts

@@ -0,0 +1,16 @@
+import { Injector } from "@venok/core/injector/injector";
+import { Abstract, Type } from "@venok/core/interfaces";
+import { Module } from "@venok/core/injector/module/module";
+import { ContextId } from "@venok/core/injector/instance/wrapper";
+import { InstanceLinksHost } from "@venok/core/injector/instance/links-host";
+import { GetOrResolveOptions } from "@venok/core/interfaces/application/context.interface";
+export declare abstract class AbstractInstanceResolver {
+    protected abstract instanceLinksHost: InstanceLinksHost;
+    protected abstract injector: Injector;
+    protected abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: GetOrResolveOptions): TResult | Array<TResult>;
+    protected find<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol, options: {
+        moduleId?: string;
+        each?: boolean;
+    }): TResult | Array<TResult>;
+    protected resolvePerContext<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol, contextModule: Module, contextId: ContextId, options?: GetOrResolveOptions): Promise<TResult | Array<TResult>>;
+}

package/injector/instance/resolver.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractInstanceResolver = void 0;
+const interfaces_1 = require("@venok/core/interfaces");
+const exceptions_1 = require("@venok/core/errors/exceptions");
+class AbstractInstanceResolver {
+    find(typeOrToken, options) {
+        const instanceLinkOrArray = this.instanceLinksHost.get(typeOrToken, options);
+        const pluckInstance = ({ wrapperRef }) => {
+            if (wrapperRef.scope === interfaces_1.Scope.REQUEST || wrapperRef.scope === interfaces_1.Scope.TRANSIENT)
+                throw new exceptions_1.InvalidClassScopeException(typeOrToken);
+            return wrapperRef.instance;
+        };
+        if (Array.isArray(instanceLinkOrArray))
+            return instanceLinkOrArray.map(pluckInstance);
+        return pluckInstance(instanceLinkOrArray);
+    }
+    async resolvePerContext(typeOrToken, contextModule, contextId, options) {
+        const instanceLinkOrArray = options?.strict
+            ? this.instanceLinksHost.get(typeOrToken, {
+                moduleId: contextModule.id,
+                each: options.each,
+            })
+            : this.instanceLinksHost.get(typeOrToken, {
+                each: options?.each ? options.each : false,
+            });
+        const pluckInstance = async (instanceLink) => {
+            const { wrapperRef, collection } = instanceLink;
+            if (wrapperRef.isDependencyTreeStatic() && !wrapperRef.isTransient)
+                return this.get(typeOrToken, { strict: options?.strict });
+            const ctorHost = wrapperRef.instance || { constructor: typeOrToken };
+            const instance = await this.injector.loadPerContext(ctorHost, wrapperRef.host, collection, contextId, wrapperRef);
+            if (!instance)
+                throw new exceptions_1.UnknownElementException();
+            return instance;
+        };
+        if (Array.isArray(instanceLinkOrArray)) {
+            return Promise.all(instanceLinkOrArray.map((instanceLink) => pluckInstance(instanceLink)));
+        }
+        return pluckInstance(instanceLinkOrArray);
+    }
+}
+exports.AbstractInstanceResolver = AbstractInstanceResolver;

package/injector/instance/wrapper.d.ts

@@ -0,0 +1,90 @@
+import { FactoryProvider, InjectionToken, Provider } from "@venok/core/interfaces/modules";
+import { Module } from "@venok/core/injector/module/module";
+import { EnhancerSubtype } from "@venok/core/constants";
+import { Scope, Type } from "@venok/core/interfaces";
+import { SettlementSignal } from "@venok/core/injector/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 | undefined;
+    isResolved?: boolean;
+    isPending?: boolean;
+    donePromise?: Promise<unknown>;
+    [INSTANCE_ID_SYMBOL]?: string;
+}
+export interface PropertyMetadata {
+    key: symbol | string;
+    wrapper: InstanceWrapper;
+}
+export declare class InstanceWrapper<T = any> {
+    readonly isAlias: boolean;
+    scope?: Scope;
+    readonly name: string;
+    readonly token: InjectionToken;
+    readonly async?: boolean;
+    readonly host?: Module;
+    readonly subtype?: EnhancerSubtype;
+    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;
+    constructor(metadata?: Partial<InstanceWrapper<T>> & Partial<InstancePerContext<T>>);
+    get id(): string;
+    set instance(value: T);
+    get instance(): T | undefined;
+    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;
+    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 | undefined): boolean;
+    isLazyTransient(contextId: ContextId, inquirer: InstanceWrapper | undefined): boolean;
+    isExplicitlyRequested(contextId: ContextId, inquirer?: InstanceWrapper): boolean;
+    isStatic(contextId: ContextId, inquirer: InstanceWrapper | undefined): boolean;
+    getStaticTransientInstances(): InstancePerContext<T>[];
+    mergeWith(provider: Provider): void;
+    private isNewable;
+    private initialize;
+    private printIntrospectedAsRequestScoped;
+    private printIntrospectedAsDurable;
+    private isDebugMode;
+    private generateUuid;
+}

package/injector/instance/wrapper.js

@@ -0,0 +1,272 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceWrapper = exports.INSTANCE_ID_SYMBOL = exports.INSTANCE_METADATA_SYMBOL = void 0;
+const interfaces_1 = require("@venok/core/interfaces");
+const constants_1 = require("@venok/core/injector/constants");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const uuid_helper_1 = require("@venok/core/helpers/uuid.helper");
+const random_string_generator_helper_1 = require("@venok/core/helpers/random-string-generator.helper");
+const color_helper_1 = require("@venok/core/helpers/color.helper");
+const classifier_helper_1 = require("@venok/core/injector/helpers/classifier.helper");
+const logger_service_1 = require("@venok/core/services/logger.service");
+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 = interfaces_1.Scope.DEFAULT;
+        this.values = new WeakMap();
+        this[_a] = {};
+        this.transientMap = new Map();
+        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_helper_1.isNull)(this.inject));
+    }
+    get isTransient() {
+        return this.scope === interfaces_1.Scope.TRANSIENT;
+    }
+    getInstanceByContextId(contextId, inquirerId) {
+        if (this.scope === interfaces_1.Scope.TRANSIENT && inquirerId) {
+            return this.getInstanceByInquirerId(contextId, inquirerId);
+        }
+        const instancePerContext = this.values.get(contextId);
+        return instancePerContext ? instancePerContext : this.cloneStaticInstance(contextId);
+    }
+    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 === interfaces_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);
+    }
+    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_helper_1.isUndefined)(this.isTreeDurable)) {
+            return this.isTreeDurable;
+        }
+        if (this.scope === interfaces_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_helper_1.isUndefined)(this.isTreeStatic))
+            return this.isTreeStatic;
+        if (this.scope === interfaces_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 === interfaces_1.Scope.TRANSIENT)));
+    }
+    isStatic(contextId, inquirer) {
+        const isInquirerRequestScoped = inquirer && !inquirer.isDependencyTreeStatic();
+        const isStaticTransient = this.isTransient && !isInquirerRequestScoped;
+        return (this.isDependencyTreeStatic() &&
+            contextId === constants_1.STATIC_CONTEXT &&
+            (!this.isTransient || (isStaticTransient && !!inquirer && !inquirer.isTransient)));
+    }
+    getStaticTransientInstances() {
+        if (!this.transientMap)
+            return [];
+        const instances = [...this.transientMap.values()];
+        return instances.map((item) => item.get(constants_1.STATIC_CONTEXT)).filter(Boolean);
+    }
+    mergeWith(provider) {
+        if ((0, classifier_helper_1.isValueProvider)(provider)) {
+            // @ts-ignore
+            this.metatype = null;
+            this.inject = null;
+            this.scope = interfaces_1.Scope.DEFAULT;
+            this.setInstanceByContextId(constants_1.STATIC_CONTEXT, {
+                instance: provider.useValue,
+                isResolved: true,
+                isPending: false,
+            });
+        }
+        else if ((0, classifier_helper_1.isClassProvider)(provider)) {
+            this.inject = null;
+            this.metatype = provider.useClass;
+        }
+        else if ((0, classifier_helper_1.isFactoryProvider)(provider)) {
+            this.metatype = provider.useFactory;
+            this.inject = provider.inject || [];
+        }
+    }
+    isNewable() {
+        return (0, shared_helper_1.isNull)(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, isResolved });
+        this.scope === interfaces_1.Scope.TRANSIENT && (this.transientMap = new Map());
+    }
+    printIntrospectedAsRequestScoped() {
+        if (!this.isDebugMode() || this.name === "REQUEST") {
+            return;
+        }
+        if ((0, shared_helper_1.isString)(this.name)) {
+            InstanceWrapper.logger.log(`${color_helper_1.colors.cyanBright(this.name)}${color_helper_1.colors.green(" introspected as ")}${color_helper_1.colors.magentaBright("request-scoped")}`);
+        }
+    }
+    printIntrospectedAsDurable() {
+        if (!this.isDebugMode()) {
+            return;
+        }
+        if ((0, shared_helper_1.isString)(this.name)) {
+            InstanceWrapper.logger.log(`${color_helper_1.colors.cyanBright(this.name)}${color_helper_1.colors.green(" introspected as ")}${color_helper_1.colors.magentaBright("durable")}`);
+        }
+    }
+    isDebugMode() {
+        return !!process.env.VENOK_DEBUG;
+    }
+    generateUuid() {
+        let key = this.name?.toString() ?? this.token?.toString();
+        key += this.host?.name ?? "";
+        return key ? uuid_helper_1.UuidFactory.get(key) : (0, random_string_generator_helper_1.randomStringGenerator)();
+    }
+}
+exports.InstanceWrapper = InstanceWrapper;
+_a = exports.INSTANCE_METADATA_SYMBOL;
+InstanceWrapper.logger = new logger_service_1.Logger(InstanceWrapper.name);

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

@@ -0,0 +1,4 @@
+import { Provider } from "@venok/core/interfaces/modules";
+export declare const ReflectorAliasProvider: Provider;
+export declare const requestProvider: Provider;
+export declare const inquirerProvider: Provider;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inquirerProvider = exports.requestProvider = exports.ReflectorAliasProvider = void 0;
+const services_1 = require("@venok/core/services");
+const constants_1 = require("@venok/core/constants");
+const interfaces_1 = require("@venok/core/interfaces");
+const noop_helper_1 = require("@venok/core/helpers/noop.helper");
+exports.ReflectorAliasProvider = {
+    provide: services_1.Reflector.name,
+    useExisting: services_1.Reflector,
+};
+exports.requestProvider = {
+    provide: constants_1.REQUEST,
+    scope: interfaces_1.Scope.REQUEST,
+    useFactory: noop_helper_1.noop,
+};
+exports.inquirerProvider = {
+    provide: constants_1.INQUIRER,
+    scope: interfaces_1.Scope.TRANSIENT,
+    useFactory: noop_helper_1.noop,
+};

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

@@ -0,0 +1,8 @@
+import { VenokContainer } from "@venok/core/injector/container";
+import { DependenciesScanner } from "@venok/core/scanner";
+import { ModuleCompiler } from "@venok/core/injector/module/compiler";
+import { GraphInspector } from "@venok/core/inspector/graph-inspector";
+import { ModuleOverride } from "@venok/core/interfaces/modules/override.interface";
+export declare class InternalCoreModuleFactory {
+    static create(container: VenokContainer, scanner: DependenciesScanner, moduleCompiler: ModuleCompiler, graphInspector: GraphInspector, moduleOverrides?: ModuleOverride[]): import("../..").DynamicModule;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalCoreModuleFactory = void 0;
+const logger_service_1 = require("@venok/core/services/logger.service");
+const loader_1 = require("@venok/core/injector/module/lazy/loader");
+const injector_1 = require("@venok/core/injector/injector");
+const loader_2 = require("@venok/core/injector/instance/loader");
+const internal_core_module_1 = require("@venok/core/injector/internal-core-module/internal-core-module");
+const container_1 = require("@venok/core/injector/module/container");
+const serialized_graph_1 = require("@venok/core/inspector/serialized-graph");
+const creator_1 = require("@venok/core/context/external/creator");
+class InternalCoreModuleFactory {
+    static create(container, scanner, moduleCompiler, graphInspector, moduleOverrides) {
+        const lazyModuleLoaderFactory = () => {
+            const logger = new logger_service_1.Logger(loader_1.LazyModuleLoader.name, {
+                timestamp: false,
+            });
+            const injector = new injector_1.Injector();
+            const instanceLoader = new loader_2.InstanceLoader(container, injector, graphInspector, logger);
+            return new loader_1.LazyModuleLoader(scanner, instanceLoader, moduleCompiler, container.getModules(), moduleOverrides);
+        };
+        return internal_core_module_1.InternalCoreModule.register([
+            {
+                provide: creator_1.ExternalContextCreator,
+                useValue: creator_1.ExternalContextCreator.fromContainer(container),
+            },
+            {
+                provide: container_1.ModulesContainer,
+                useValue: container.getModules(),
+            },
+            {
+                provide: loader_1.LazyModuleLoader,
+                useFactory: lazyModuleLoaderFactory,
+            },
+            {
+                provide: serialized_graph_1.SerializedGraph,
+                useValue: container.serializedGraph,
+            },
+        ]);
+    }
+}
+exports.InternalCoreModuleFactory = InternalCoreModuleFactory;

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

@@ -0,0 +1,4 @@
+import { DynamicModule, ExistingProvider, FactoryProvider, ValueProvider } from "@venok/core/interfaces/modules";
+export declare class InternalCoreModule {
+    static register(providers: Array<ValueProvider | FactoryProvider | ExistingProvider>): DynamicModule;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var InternalCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalCoreModule = void 0;
+const services_1 = require("@venok/core/services");
+const global_decorator_1 = require("@venok/core/decorators/global.decorator");
+const module_decorator_1 = require("@venok/core/decorators/module.decorator");
+const core_providers_1 = require("@venok/core/injector/internal-core-module/core-providers");
+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 = __decorate([
+    (0, global_decorator_1.Global)(),
+    (0, module_decorator_1.Module)({
+        providers: [services_1.Reflector, core_providers_1.ReflectorAliasProvider, core_providers_1.requestProvider, core_providers_1.inquirerProvider],
+        exports: [services_1.Reflector, core_providers_1.ReflectorAliasProvider, core_providers_1.requestProvider, core_providers_1.inquirerProvider],
+    })
+], InternalCoreModule);

package/injector/module/compiler.d.ts

@@ -0,0 +1,19 @@
+import { Type } from "@venok/core/interfaces";
+import { DynamicModule } from "@venok/core/interfaces/modules/dynamic-module.interface";
+import { ForwardReference } from "@venok/core/interfaces/modules/forward-reference.interface";
+import { TokenFactory } from "@venok/core/injector/module/token-factory";
+export interface ModuleFactory {
+    type: Type<any>;
+    token: string;
+    dynamicMetadata?: Partial<DynamicModule>;
+}
+export declare class ModuleCompiler {
+    private readonly moduleTokenFactory;
+    constructor(moduleTokenFactory?: TokenFactory);
+    compile(metatype: Type<any> | DynamicModule | Promise<DynamicModule>): Promise<ModuleFactory>;
+    extractMetadata(metatype: Type<any> | ForwardReference | DynamicModule): {
+        type: Type<any>;
+        dynamicMetadata?: Partial<DynamicModule> | undefined;
+    };
+    isDynamicModule(module: Type<any> | DynamicModule | ForwardReference): module is DynamicModule;
+}

package/injector/module/compiler.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleCompiler = void 0;
+const token_factory_1 = require("@venok/core/injector/module/token-factory");
+class ModuleCompiler {
+    constructor(moduleTokenFactory = new token_factory_1.TokenFactory()) {
+        this.moduleTokenFactory = moduleTokenFactory;
+    }
+    async compile(metatype) {
+        const { type, dynamicMetadata } = this.extractMetadata(await metatype);
+        const token = this.moduleTokenFactory.create(type, dynamicMetadata);
+        return { type, dynamicMetadata, token };
+    }
+    extractMetadata(metatype) {
+        if (!this.isDynamicModule(metatype)) {
+            return {
+                type: metatype?.forwardRef ? metatype.forwardRef() : metatype,
+            };
+        }
+        const { module: type, ...dynamicMetadata } = metatype;
+        return { type, dynamicMetadata };
+    }
+    isDynamicModule(module) {
+        return !!module.module;
+    }
+}
+exports.ModuleCompiler = ModuleCompiler;