@venok/core 1.0.0

package/application/config.d.ts

@@ -0,0 +1,35 @@
+import { CanActivate } from "@venok/core/interfaces/features/guards.interface";
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+import { PipeTransform } from "@venok/core/interfaces/features/pipes.interface";
+import { ExceptionFilter } from "@venok/core/interfaces/features/exception-filter.interface";
+import { VenokInterceptor } from "@venok/core/interfaces/features/interceptor.interface";
+export declare class ApplicationConfig {
+    private globalPipes;
+    private globalFilters;
+    private globalInterceptors;
+    private globalGuards;
+    private readonly globalRequestPipes;
+    private readonly globalRequestFilters;
+    private readonly globalRequestInterceptors;
+    private readonly globalRequestGuards;
+    addGlobalPipe(pipe: PipeTransform<any>): void;
+    useGlobalPipes(...pipes: PipeTransform<any>[]): void;
+    getGlobalFilters(): ExceptionFilter[];
+    addGlobalFilter(filter: ExceptionFilter): void;
+    useGlobalFilters(...filters: ExceptionFilter[]): void;
+    getGlobalPipes(): PipeTransform<any>[];
+    getGlobalInterceptors(): VenokInterceptor[];
+    addGlobalInterceptor(interceptor: VenokInterceptor): void;
+    useGlobalInterceptors(...interceptors: VenokInterceptor[]): void;
+    getGlobalGuards(): CanActivate[];
+    addGlobalGuard(guard: CanActivate): void;
+    useGlobalGuards(...guards: CanActivate[]): void;
+    addGlobalRequestInterceptor(wrapper: InstanceWrapper<VenokInterceptor>): void;
+    getGlobalRequestInterceptors(): InstanceWrapper<VenokInterceptor>[];
+    addGlobalRequestPipe(wrapper: InstanceWrapper<PipeTransform>): void;
+    getGlobalRequestPipes(): InstanceWrapper<PipeTransform>[];
+    addGlobalRequestFilter(wrapper: InstanceWrapper<ExceptionFilter>): void;
+    getGlobalRequestFilters(): InstanceWrapper<ExceptionFilter>[];
+    addGlobalRequestGuard(wrapper: InstanceWrapper<CanActivate>): void;
+    getGlobalRequestGuards(): InstanceWrapper<CanActivate>[];
+}

package/application/config.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationConfig = void 0;
+class ApplicationConfig {
+    constructor() {
+        this.globalPipes = [];
+        this.globalFilters = [];
+        this.globalInterceptors = [];
+        this.globalGuards = [];
+        this.globalRequestPipes = [];
+        this.globalRequestFilters = [];
+        this.globalRequestInterceptors = [];
+        this.globalRequestGuards = [];
+    }
+    // constructor(private ioAdapter: WebSocketAdapter | null = null) {}
+    //
+    // public setIoAdapter(ioAdapter: WebSocketAdapter) {
+    //   this.ioAdapter = ioAdapter;
+    // }
+    //
+    // public getIoAdapter(): WebSocketAdapter {
+    //   return this.ioAdapter;
+    // }
+    addGlobalPipe(pipe) {
+        this.globalPipes.push(pipe);
+    }
+    useGlobalPipes(...pipes) {
+        this.globalPipes = this.globalPipes.concat(pipes);
+    }
+    getGlobalFilters() {
+        return this.globalFilters;
+    }
+    addGlobalFilter(filter) {
+        this.globalFilters.push(filter);
+    }
+    useGlobalFilters(...filters) {
+        this.globalFilters = this.globalFilters.concat(filters);
+    }
+    getGlobalPipes() {
+        return this.globalPipes;
+    }
+    getGlobalInterceptors() {
+        return this.globalInterceptors;
+    }
+    addGlobalInterceptor(interceptor) {
+        this.globalInterceptors.push(interceptor);
+    }
+    useGlobalInterceptors(...interceptors) {
+        this.globalInterceptors = this.globalInterceptors.concat(interceptors);
+    }
+    getGlobalGuards() {
+        return this.globalGuards;
+    }
+    addGlobalGuard(guard) {
+        this.globalGuards.push(guard);
+    }
+    useGlobalGuards(...guards) {
+        this.globalGuards = this.globalGuards.concat(guards);
+    }
+    addGlobalRequestInterceptor(wrapper) {
+        this.globalRequestInterceptors.push(wrapper);
+    }
+    getGlobalRequestInterceptors() {
+        return this.globalRequestInterceptors;
+    }
+    addGlobalRequestPipe(wrapper) {
+        this.globalRequestPipes.push(wrapper);
+    }
+    getGlobalRequestPipes() {
+        return this.globalRequestPipes;
+    }
+    addGlobalRequestFilter(wrapper) {
+        this.globalRequestFilters.push(wrapper);
+    }
+    getGlobalRequestFilters() {
+        return this.globalRequestFilters;
+    }
+    addGlobalRequestGuard(wrapper) {
+        this.globalRequestGuards.push(wrapper);
+    }
+    getGlobalRequestGuards() {
+        return this.globalRequestGuards;
+    }
+}
+exports.ApplicationConfig = ApplicationConfig;

package/application/context.d.ts

@@ -0,0 +1,198 @@
+import { AbstractInstanceResolver } from "@venok/core/injector/instance/resolver";
+import { Injector } from "@venok/core/injector/injector";
+import { Logger, LoggerService, LogLevel } from "@venok/core/services/logger.service";
+import { InstanceLinksHost } from "@venok/core/injector/instance/links-host";
+import { Module } from "@venok/core/injector/module/module";
+import { DynamicModule, Type } from "@venok/core/interfaces";
+import { VenokContainer } from "@venok/core/injector/container";
+import { ContextId } from "@venok/core/injector/instance/wrapper";
+import { ApplicationContextOptions } from "@venok/core/interfaces/application/context-options.interface";
+import { VenokApplicationContext } from "@venok/core/interfaces/application/context.interface";
+import { ApplicationConfig } from "@venok/core/application/config";
+import { VenokInterceptor } from "@venok/core/interfaces/features/interceptor.interface";
+import { CanActivate } from "@venok/core/interfaces/features/guards.interface";
+import { ExceptionFilter } from "@venok/core/interfaces/features/exception-filter.interface";
+import { PipeTransform } from "@venok/core/interfaces/features/pipes.interface";
+/**
+ * System signals which shut down a process
+ */
+export declare enum ShutdownSignal {
+    SIGHUP = "SIGHUP",
+    SIGINT = "SIGINT",
+    SIGQUIT = "SIGQUIT",
+    SIGILL = "SIGILL",
+    SIGTRAP = "SIGTRAP",
+    SIGABRT = "SIGABRT",
+    SIGBUS = "SIGBUS",
+    SIGFPE = "SIGFPE",
+    SIGSEGV = "SIGSEGV",
+    SIGUSR2 = "SIGUSR2",
+    SIGTERM = "SIGTERM"
+}
+export type ShutdownSignalKeys = keyof typeof ShutdownSignal;
+/**
+ * @publicApi
+ */
+export declare class ApplicationContext<TOptions extends ApplicationContextOptions = ApplicationContextOptions> extends AbstractInstanceResolver implements VenokApplicationContext {
+    protected readonly container: VenokContainer;
+    protected readonly config: ApplicationConfig;
+    protected readonly appOptions: TOptions;
+    private contextModule;
+    private readonly scope;
+    protected isInitialized: boolean;
+    protected injector: Injector;
+    protected readonly logger: Logger;
+    private shouldFlushLogsOnOverride;
+    private readonly activeShutdownSignals;
+    private readonly moduleCompiler;
+    private shutdownCleanupRef?;
+    private _instanceLinksHost;
+    private _moduleRefsForHooksByDistance?;
+    protected get instanceLinksHost(): InstanceLinksHost;
+    constructor(container: VenokContainer, config: ApplicationConfig, appOptions?: TOptions, contextModule?: Module, scope?: Type<any>[]);
+    selectContextModule(): void;
+    /**
+     * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
+     * @returns {VenokApplicationContext}
+     */
+    select<T>(moduleType: Type<T> | DynamicModule): VenokApplicationContext;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    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}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each?: undefined | false;
+    }): TResult;
+    /**
+     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each: true;
+    }): Array<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    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>}
+     */
+    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>}
+     */
+    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>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each: true;
+    }): Promise<Array<TResult>>;
+    /**
+     * Registers the request/context object for a given context ID (DI container sub-tree).
+     * @returns {void}
+     */
+    registerRequestByContextId<T = any>(request: T, contextId: ContextId): void;
+    /**
+     * Initializes the Venok application.
+     * Calls the Venok lifecycle events.
+     *
+     * @returns {Promise<this>} The ApplicationContext instance as Promise
+     */
+    init(): Promise<this>;
+    /**
+     * Terminates the application
+     * @returns {Promise<void>}
+     */
+    close(signal?: string): Promise<void>;
+    /**
+     * Sets custom logger service.
+     * Flushes buffered logs if auto flush is on.
+     * @returns {void}
+     */
+    useLogger(logger: LoggerService | LogLevel[] | false): void;
+    useGlobalFilters(...filters: ExceptionFilter[]): this;
+    useGlobalPipes(...pipes: PipeTransform<any>[]): this;
+    useGlobalInterceptors(...interceptors: VenokInterceptor[]): this;
+    useGlobalGuards(...guards: CanActivate[]): this;
+    /**
+     * Prints buffered logs and detaches buffer.
+     * @returns {void}
+     */
+    flushLogs(): void;
+    /**
+     * Define that it must flush logs right after defining a custom logger.
+     */
+    flushLogsOnOverride(): void;
+    /**
+     * Enables the usage of shutdown hooks. Will call the
+     * `onApplicationShutdown` function of a provider if the
+     * process receives a shutdown signal.
+     *
+     * @param {ShutdownSignal[]} [signals=[]] The system signals it should listen to
+     *
+     * @returns {this} The Venok application context instance
+     */
+    enableShutdownHooks(signals?: (ShutdownSignal | string)[]): this;
+    protected dispose(): Promise<void>;
+    /**
+     * Listens to shutdown signals by listening to
+     * process events
+     *
+     * @param {string[]} signals The system signals it should listen to
+     */
+    protected listenToShutdownSignals(signals: string[]): void;
+    /**
+     * Unsubscribes from shutdown signals (process events)
+     */
+    protected unsubscribeFromProcessSignals(): void;
+    /**
+     * Calls the `onModuleInit` function on the registered
+     * modules and its children.
+     */
+    protected callInitHook(): Promise<void>;
+    /**
+     * Calls the `onModuleDestroy` function on the registered
+     * modules and its children.
+     */
+    protected callDestroyHook(): Promise<void>;
+    /**
+     * Calls the `onApplicationBootstrap` function on the registered
+     * modules and its children.
+     */
+    protected callBootstrapHook(): Promise<void>;
+    /**
+     * Calls the `onApplicationShutdown` function on the registered
+     * modules and children.
+     */
+    protected callShutdownHook(signal?: string): Promise<void>;
+    /**
+     * Calls the `beforeApplicationShutdown` function on the registered
+     * modules and children.
+     */
+    protected callBeforeShutdownHook(signal?: string): Promise<void>;
+    protected assertNotInPreviewMode(methodName: string): void;
+    private getModulesToTriggerHooksOn;
+    private printInPreviewModeWarning;
+}

package/application/context.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationContext = exports.ShutdownSignal = void 0;
+const resolver_1 = require("@venok/core/injector/instance/resolver");
+const injector_1 = require("@venok/core/injector/injector");
+const logger_service_1 = require("@venok/core/services/logger.service");
+const compiler_1 = require("@venok/core/injector/module/compiler");
+const links_host_1 = require("@venok/core/injector/instance/links-host");
+const exceptions_1 = require("@venok/core/errors/exceptions");
+const context_id_factory_helper_1 = require("@venok/core/helpers/context-id-factory.helper");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const hooks_1 = require("@venok/core/hooks");
+const constants_1 = require("@venok/core/constants");
+/**
+ * System signals which shut down a process
+ */
+var ShutdownSignal;
+(function (ShutdownSignal) {
+    ShutdownSignal["SIGHUP"] = "SIGHUP";
+    ShutdownSignal["SIGINT"] = "SIGINT";
+    ShutdownSignal["SIGQUIT"] = "SIGQUIT";
+    ShutdownSignal["SIGILL"] = "SIGILL";
+    ShutdownSignal["SIGTRAP"] = "SIGTRAP";
+    ShutdownSignal["SIGABRT"] = "SIGABRT";
+    ShutdownSignal["SIGBUS"] = "SIGBUS";
+    ShutdownSignal["SIGFPE"] = "SIGFPE";
+    ShutdownSignal["SIGSEGV"] = "SIGSEGV";
+    ShutdownSignal["SIGUSR2"] = "SIGUSR2";
+    ShutdownSignal["SIGTERM"] = "SIGTERM";
+})(ShutdownSignal || (exports.ShutdownSignal = ShutdownSignal = {}));
+/**
+ * @publicApi
+ */
+class ApplicationContext extends resolver_1.AbstractInstanceResolver {
+    get instanceLinksHost() {
+        if (!this._instanceLinksHost) {
+            this._instanceLinksHost = new links_host_1.InstanceLinksHost(this.container);
+        }
+        return this._instanceLinksHost;
+    }
+    constructor(container, config, appOptions = {}, contextModule = null, scope = new Array()) {
+        super();
+        this.container = container;
+        this.config = config;
+        this.appOptions = appOptions;
+        this.contextModule = contextModule;
+        this.scope = scope;
+        this.isInitialized = false;
+        this.logger = new logger_service_1.Logger(ApplicationContext.name, {
+            timestamp: true,
+        });
+        this.shouldFlushLogsOnOverride = false;
+        this.activeShutdownSignals = new Array();
+        this.moduleCompiler = new compiler_1.ModuleCompiler();
+        this.injector = new injector_1.Injector();
+        if (this.appOptions.preview) {
+            this.printInPreviewModeWarning();
+        }
+    }
+    selectContextModule() {
+        const modules = this.container.getModules().values();
+        this.contextModule = modules.next().value;
+    }
+    /**
+     * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
+     * @returns {VenokApplicationContext}
+     */
+    select(moduleType) {
+        const modulesContainer = this.container.getModules();
+        const contextModuleCtor = this.contextModule.metatype;
+        const scope = this.scope.concat(contextModuleCtor);
+        const moduleTokenFactory = this.container.getModuleTokenFactory();
+        const { type, dynamicMetadata } = this.moduleCompiler.extractMetadata(moduleType);
+        const token = moduleTokenFactory.create(type, dynamicMetadata);
+        const selectedModule = modulesContainer.get(token);
+        if (!selectedModule) {
+            throw new exceptions_1.UnknownModuleException();
+        }
+        return new ApplicationContext(this.container, this.config, this.appOptions, selectedModule, scope);
+    }
+    /**
+     * Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult | Array<TResult>}
+     */
+    get(typeOrToken, options = { strict: false }) {
+        return !(options && options.strict)
+            ? this.find(typeOrToken, options)
+            : this.find(typeOrToken, {
+                moduleId: this.contextModule?.id,
+                each: options.each,
+            });
+    }
+    /**
+     * Resolves transient or request-scoped instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {Promise<TResult | Array<TResult>>}
+     */
+    resolve(typeOrToken, contextId = (0, context_id_factory_helper_1.createContextId)(), options = { strict: false }) {
+        return this.resolvePerContext(typeOrToken, this.contextModule, contextId, options);
+    }
+    /**
+     * Registers the request/context object for a given context ID (DI container sub-tree).
+     * @returns {void}
+     */
+    registerRequestByContextId(request, contextId) {
+        this.container.registerRequestProvider(request, contextId);
+    }
+    /**
+     * Initializes the Venok application.
+     * Calls the Venok lifecycle events.
+     *
+     * @returns {Promise<this>} The ApplicationContext instance as Promise
+     */
+    async init() {
+        if (this.isInitialized) {
+            return this;
+        }
+        await this.callInitHook();
+        await this.callBootstrapHook();
+        this.isInitialized = true;
+        return this;
+    }
+    /**
+     * Terminates the application
+     * @returns {Promise<void>}
+     */
+    async close(signal) {
+        await this.callDestroyHook();
+        await this.callBeforeShutdownHook(signal);
+        await this.dispose();
+        await this.callShutdownHook(signal);
+        this.unsubscribeFromProcessSignals();
+    }
+    /**
+     * Sets custom logger service.
+     * Flushes buffered logs if auto flush is on.
+     * @returns {void}
+     */
+    useLogger(logger) {
+        logger_service_1.Logger.overrideLogger(logger);
+        if (this.shouldFlushLogsOnOverride) {
+            this.flushLogs();
+        }
+    }
+    useGlobalFilters(...filters) {
+        this.config.useGlobalFilters(...filters);
+        return this;
+    }
+    useGlobalPipes(...pipes) {
+        this.config.useGlobalPipes(...pipes);
+        return this;
+    }
+    useGlobalInterceptors(...interceptors) {
+        this.config.useGlobalInterceptors(...interceptors);
+        return this;
+    }
+    useGlobalGuards(...guards) {
+        this.config.useGlobalGuards(...guards);
+        return this;
+    }
+    /**
+     * Prints buffered logs and detaches buffer.
+     * @returns {void}
+     */
+    flushLogs() {
+        logger_service_1.Logger.flush();
+    }
+    /**
+     * Define that it must flush logs right after defining a custom logger.
+     */
+    flushLogsOnOverride() {
+        this.shouldFlushLogsOnOverride = true;
+    }
+    /**
+     * Enables the usage of shutdown hooks. Will call the
+     * `onApplicationShutdown` function of a provider if the
+     * process receives a shutdown signal.
+     *
+     * @param {ShutdownSignal[]} [signals=[]] The system signals it should listen to
+     *
+     * @returns {this} The Venok application context instance
+     */
+    enableShutdownHooks(signals = []) {
+        if ((0, shared_helper_1.isEmpty)(signals)) {
+            const keys = Object.keys(ShutdownSignal);
+            signals = keys.map((key) => ShutdownSignal[key]);
+        }
+        else {
+            // given signals array should be unique because
+            // process shouldn't listen to the same signal more than once.
+            signals = Array.from(new Set(signals));
+        }
+        signals = signals
+            .map((signal) => signal.toString().toUpperCase().trim())
+            // filter out the signals which is already listening to
+            .filter((signal) => !this.activeShutdownSignals.includes(signal));
+        this.listenToShutdownSignals(signals);
+        return this;
+    }
+    async dispose() {
+        // Venok application context has no server
+        // to dispose, therefore just call a noop
+        return Promise.resolve();
+    }
+    /**
+     * Listens to shutdown signals by listening to
+     * process events
+     *
+     * @param {string[]} signals The system signals it should listen to
+     */
+    listenToShutdownSignals(signals) {
+        let receivedSignal = false;
+        const cleanup = async (signal) => {
+            try {
+                if (receivedSignal) {
+                    // If we receive another signal while we're waiting
+                    // for the server to stop, just ignore it.
+                    return;
+                }
+                receivedSignal = true;
+                await this.callDestroyHook();
+                await this.callBeforeShutdownHook(signal);
+                await this.dispose();
+                await this.callShutdownHook(signal);
+                signals.forEach((sig) => process.removeListener(sig, cleanup));
+                process.kill(process.pid, signal);
+            }
+            catch (err) {
+                logger_service_1.Logger.error(constants_1.MESSAGES.ERROR_DURING_SHUTDOWN, err?.stack, ApplicationContext.name);
+                process.exit(1);
+            }
+        };
+        this.shutdownCleanupRef = cleanup;
+        signals.forEach((signal) => {
+            this.activeShutdownSignals.push(signal);
+            process.on(signal, cleanup);
+        });
+    }
+    /**
+     * Unsubscribes from shutdown signals (process events)
+     */
+    unsubscribeFromProcessSignals() {
+        if (!this.shutdownCleanupRef) {
+            return;
+        }
+        this.activeShutdownSignals.forEach((signal) => {
+            process.removeListener(signal, this.shutdownCleanupRef);
+        });
+    }
+    /**
+     * Calls the `onModuleInit` function on the registered
+     * modules and its children.
+     */
+    async callInitHook() {
+        const modulesSortedByDistance = this.getModulesToTriggerHooksOn();
+        for (const module of modulesSortedByDistance) {
+            await (0, hooks_1.callModuleInitHook)(module);
+        }
+    }
+    /**
+     * Calls the `onModuleDestroy` function on the registered
+     * modules and its children.
+     */
+    async callDestroyHook() {
+        const modulesSortedByDistance = this.getModulesToTriggerHooksOn();
+        for (const module of modulesSortedByDistance) {
+            await (0, hooks_1.callModuleDestroyHook)(module);
+        }
+    }
+    /**
+     * Calls the `onApplicationBootstrap` function on the registered
+     * modules and its children.
+     */
+    async callBootstrapHook() {
+        const modulesSortedByDistance = this.getModulesToTriggerHooksOn();
+        for (const module of modulesSortedByDistance) {
+            await (0, hooks_1.callModuleBootstrapHook)(module);
+        }
+    }
+    /**
+     * Calls the `onApplicationShutdown` function on the registered
+     * modules and children.
+     */
+    async callShutdownHook(signal) {
+        const modulesSortedByDistance = this.getModulesToTriggerHooksOn();
+        for (const module of modulesSortedByDistance) {
+            await (0, hooks_1.callAppShutdownHook)(module, signal);
+        }
+    }
+    /**
+     * Calls the `beforeApplicationShutdown` function on the registered
+     * modules and children.
+     */
+    async callBeforeShutdownHook(signal) {
+        const modulesSortedByDistance = this.getModulesToTriggerHooksOn();
+        for (const module of modulesSortedByDistance) {
+            await (0, hooks_1.callBeforeAppShutdownHook)(module, signal);
+        }
+    }
+    assertNotInPreviewMode(methodName) {
+        if (this.appOptions.preview) {
+            const error = `Calling the "${methodName}" in the preview mode is not supported.`;
+            this.logger.error(error);
+            throw new Error(error);
+        }
+    }
+    getModulesToTriggerHooksOn() {
+        if (this._moduleRefsForHooksByDistance) {
+            return this._moduleRefsForHooksByDistance;
+        }
+        const modulesContainer = this.container.getModules();
+        const compareFn = (a, b) => b.distance - a.distance;
+        const modulesSortedByDistance = Array.from(modulesContainer.values()).sort(compareFn);
+        this._moduleRefsForHooksByDistance = this.appOptions?.preview
+            ? modulesSortedByDistance.filter((moduleRef) => moduleRef.initOnPreview)
+            : modulesSortedByDistance;
+        return this._moduleRefsForHooksByDistance;
+    }
+    printInPreviewModeWarning() {
+        this.logger.warn("------------------------------------------------");
+        this.logger.warn("Application is running in the PREVIEW mode!");
+        this.logger.warn("Providers will not be instantiated.");
+        this.logger.warn("------------------------------------------------");
+    }
+}
+exports.ApplicationContext = ApplicationContext;

package/application/factory.d.ts

@@ -0,0 +1,43 @@
+import { VenokApplicationContext } from "@venok/core/interfaces";
+import { ApplicationContextOptions } from "@venok/core/interfaces/application/context-options.interface";
+/**
+ * @publicApi
+ */
+export declare class VenokFactoryStatic {
+    private readonly logger;
+    private abortOnError;
+    private autoFlushLogs;
+    /**
+     * Creates an instance of VenokApplicationContext.
+     *
+     * @param moduleCls Entry (root) application module class
+     * @param options Optional Venok application configuration
+     *
+     * @returns A promise that, when resolved,
+     * contains a reference to the VenokApplicationContext instance.
+     */
+    createApplicationContext(moduleCls: any, options?: ApplicationContextOptions): Promise<VenokApplicationContext>;
+    private createVenokInstance;
+    private setAbortOnError;
+    private initialize;
+    private handleInitializationError;
+    private createProxy;
+    private createExceptionProxy;
+    private createExceptionZone;
+    private registerLoggerConfiguration;
+    private createGraphInspector;
+}
+/**
+ * Use VenokFactory to create an application instance.
+ *
+ * ### Specifying an entry module
+ *
+ * Pass the required *root module* for the application via the module parameter.
+ * By convention, it is usually called `ApplicationModule`.  Starting with this
+ * module, Venok assembles the dependency graph and begins the process of
+ * Dependency Injection and instantiates the classes needed to launch your
+ * application.
+ *
+ * @publicApi
+ */
+export declare const VenokFactory: VenokFactoryStatic;