@venok/core 1.0.0

package/errors/exceptions/undefined-dependency.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndefinedDependencyException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class UndefinedDependencyException extends runtime_exception_1.RuntimeException {
+    constructor(type, undefinedDependencyContext, module) {
+        super((0, messages_1.UNKNOWN_DEPENDENCIES_MESSAGE)(type, undefinedDependencyContext, module));
+    }
+}
+exports.UndefinedDependencyException = UndefinedDependencyException;

package/errors/exceptions/undefined-forwardref.exception.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeException } from "./runtime.exception";
+import { Type } from "@venok/core/interfaces";
+export declare class UndefinedForwardRefException extends RuntimeException {
+    constructor(scope: Type<any>[]);
+}

package/errors/exceptions/undefined-forwardref.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndefinedForwardRefException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class UndefinedForwardRefException extends runtime_exception_1.RuntimeException {
+    constructor(scope) {
+        super((0, messages_1.UNDEFINED_FORWARDREF_MESSAGE)(scope));
+    }
+}
+exports.UndefinedForwardRefException = UndefinedForwardRefException;

package/errors/exceptions/undefined-module.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from "./runtime.exception";
+export declare class UndefinedModuleException extends RuntimeException {
+    constructor(parentModule: any, index: number, scope: any[]);
+}

package/errors/exceptions/undefined-module.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndefinedModuleException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
+class UndefinedModuleException extends runtime_exception_1.RuntimeException {
+    constructor(parentModule, index, scope) {
+        super((0, messages_1.UNDEFINED_MODULE_MESSAGE)(parentModule, index, scope));
+    }
+}
+exports.UndefinedModuleException = UndefinedModuleException;

package/errors/exceptions/unknown-dependencies.exception.d.ts

@@ -0,0 +1,16 @@
+import { InjectorDependencyContext } from "../../injector/injector";
+import { Module } from "../../injector/module/module";
+import { RuntimeException } from "./runtime.exception";
+export declare class UnknownDependenciesException extends RuntimeException {
+    readonly type: string | symbol;
+    readonly context: InjectorDependencyContext;
+    readonly metadata?: {
+        id: string;
+    } | undefined;
+    readonly moduleRef: {
+        id: string;
+    } | undefined;
+    constructor(type: string | symbol, context: InjectorDependencyContext, moduleRef: Module, metadata?: {
+        id: string;
+    } | undefined);
+}

package/errors/exceptions/unknown-dependencies.exception.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownDependenciesException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownDependenciesException extends runtime_exception_1.RuntimeException {
+    constructor(type, context, moduleRef, metadata) {
+        super((0, messages_1.UNKNOWN_DEPENDENCIES_MESSAGE)(type, context, moduleRef));
+        this.type = type;
+        this.context = context;
+        this.metadata = metadata;
+        this.moduleRef = moduleRef && { id: moduleRef.id };
+    }
+}
+exports.UnknownDependenciesException = UnknownDependenciesException;

package/errors/exceptions/unknown-element.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from "./runtime.exception";
+export declare class UnknownElementException extends RuntimeException {
+    constructor(name?: string | symbol);
+}

package/errors/exceptions/unknown-element.exception.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownElementException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownElementException extends runtime_exception_1.RuntimeException {
+    constructor(name) {
+        name = name && name.toString();
+        super(`Venok could not find ${name || "given"} 
+       element (this provider does not exist in the current context)`);
+    }
+}
+exports.UnknownElementException = UnknownElementException;

package/errors/exceptions/unknown-export.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from "./runtime.exception";
+export declare class UnknownExportException extends RuntimeException {
+    constructor(token: string | symbol, moduleName: string);
+}

package/errors/exceptions/unknown-export.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownExportException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownExportException extends runtime_exception_1.RuntimeException {
+    constructor(token, moduleName) {
+        super((0, messages_1.UNKNOWN_EXPORT_MESSAGE)(token, moduleName));
+    }
+}
+exports.UnknownExportException = UnknownExportException;

package/errors/exceptions/unknown-module.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from "./runtime.exception";
+export declare class UnknownModuleException extends RuntimeException {
+    constructor();
+}

package/errors/exceptions/unknown-module.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownModuleException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownModuleException extends runtime_exception_1.RuntimeException {
+    constructor() {
+        super("Venok could not select the given module (it does not exist in current context)");
+    }
+}
+exports.UnknownModuleException = UnknownModuleException;

package/errors/messages.d.ts

@@ -0,0 +1,15 @@
+import { InjectorDependencyContext } from "@venok/core/injector/injector";
+import { ForwardReference } from "@venok/core/interfaces/modules";
+import { Module } from "@venok/core/injector/module/module";
+import { Type } from "@venok/core/interfaces";
+export declare const UNKNOWN_DEPENDENCIES_MESSAGE: (type: string | symbol, unknownDependencyContext: InjectorDependencyContext, module: Module) => string;
+export declare const UNDEFINED_FORWARDREF_MESSAGE: (scope: Type<any>[]) => string;
+export declare const INVALID_MODULE_MESSAGE: (parentModule: any, index: number, scope: any[]) => string;
+export declare const USING_INVALID_CLASS_AS_A_MODULE_MESSAGE: (metatypeUsedAsAModule: Type | ForwardReference, scope: any[]) => string;
+export declare const UNDEFINED_MODULE_MESSAGE: (parentModule: any, index: number, scope: any[]) => string;
+export declare const UNKNOWN_EXPORT_MESSAGE: (token: string | symbol | undefined, module: string) => string;
+export declare const INVALID_CLASS_MESSAGE: (text: TemplateStringsArray, value: any) => string;
+export declare const INVALID_CLASS_SCOPE_MESSAGE: (text: TemplateStringsArray, name: string | undefined) => string;
+export declare const UNHANDLED_RUNTIME_EXCEPTION = "Unhandled Runtime Exception.";
+export declare const INVALID_EXCEPTION_FILTER = "Invalid exception filters (@UseFilters()).";
+export declare const MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = "Unable to load @Venok/microservices package. (Please make sure that it's already installed.)";

package/errors/messages.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = exports.INVALID_EXCEPTION_FILTER = exports.UNHANDLED_RUNTIME_EXCEPTION = exports.INVALID_CLASS_SCOPE_MESSAGE = exports.INVALID_CLASS_MESSAGE = exports.UNKNOWN_EXPORT_MESSAGE = exports.UNDEFINED_MODULE_MESSAGE = exports.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = exports.INVALID_MODULE_MESSAGE = exports.UNDEFINED_FORWARDREF_MESSAGE = exports.UNKNOWN_DEPENDENCIES_MESSAGE = void 0;
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+/**
+ * Returns the name of an instance or `undefined`
+ * @param instance The instance which should get the name from
+ */
+const getInstanceName = (instance) => {
+    if (instance?.forwardRef)
+        return instance.forwardRef()?.name;
+    if (instance?.module)
+        return instance.module?.name;
+    return instance?.name;
+};
+/**
+ * Returns the name of the dependency
+ * Tries to get the class name, otherwise the string value
+ * (= injection token). As fallback, it returns '+'
+ * @param dependency The name of the dependency to be displayed
+ */
+const getDependencyName = (dependency) => 
+// use class name
+getInstanceName(dependency) ||
+    // use injection token (symbol)
+    ((0, shared_helper_1.isSymbol)(dependency) && dependency.toString()) ||
+    // use string directly
+    dependency ||
+    // otherwise
+    "+";
+/**
+ * Returns the name of the module
+ * Tries to get the class name. As fallback, it returns 'current'.
+ * @param module The module which should get displayed
+ */
+const getModuleName = (module) => (module && getInstanceName(module.metatype)) || "current";
+const stringifyScope = (scope) => (scope || []).map(getInstanceName).join(" -> ");
+const UNKNOWN_DEPENDENCIES_MESSAGE = (type, unknownDependencyContext, module) => {
+    const { index, name = "dependency", dependencies, key } = unknownDependencyContext;
+    const moduleName = getModuleName(module);
+    const dependencyName = getDependencyName(name);
+    const potentialSolutions = 
+    // If module's name is well-defined
+    moduleName !== "current"
+        ? `\n
+Potential solutions:
+- Is ${moduleName} a valid Venok module?
+- If ${dependencyName} is a provider, is it part of the current ${moduleName}?
+- If ${dependencyName} is exported from a separate @Module, is that module imported within ${moduleName}?
+  @Module({
+    imports: [ /* the Module containing ${dependencyName} */ ]
+  })
+`
+        : `\n
+Potential solutions:
+- If ${dependencyName} is a provider, is it part of the current Module?
+- If ${dependencyName} is exported from a separate @Module, is that module imported within Module?
+  @Module({
+    imports: [ /* the Module containing ${dependencyName} */ ]
+  })
+`;
+    let message = `Venok can't resolve dependencies of the ${type.toString()}`;
+    if ((0, shared_helper_1.isNull)(index) && key) {
+        message += `. Please make sure that the "${key.toString()}" property is available in the current context.${potentialSolutions}`;
+        return message;
+    }
+    const dependenciesName = (dependencies || []).map(getDependencyName);
+    // @ts-ignore
+    dependenciesName[index] = "?";
+    message += ` (`;
+    message += dependenciesName.join(", ");
+    message += `). Please make sure that the argument ${dependencyName} at index [${index}] is available in the ${moduleName} context.`;
+    message += potentialSolutions;
+    return message;
+};
+exports.UNKNOWN_DEPENDENCIES_MESSAGE = UNKNOWN_DEPENDENCIES_MESSAGE;
+const UNDEFINED_FORWARDREF_MESSAGE = (scope) => `Venok cannot create the module instance. Often, this is because of a circular dependency between modules. Use forwardRef() to avoid it.
+
+Scope [${stringifyScope(scope)}]
+`;
+exports.UNDEFINED_FORWARDREF_MESSAGE = UNDEFINED_FORWARDREF_MESSAGE;
+const INVALID_MODULE_MESSAGE = (parentModule, index, scope) => {
+    const parentModuleName = parentModule?.name || "module";
+    return `Venok cannot create the ${parentModuleName} instance.
+Received an unexpected value at index [${index}] of the ${parentModuleName} "imports" array.
+
+Scope [${stringifyScope(scope)}]`;
+};
+exports.INVALID_MODULE_MESSAGE = INVALID_MODULE_MESSAGE;
+const USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = (metatypeUsedAsAModule, scope) => {
+    const metatypeNameQuote = `"${getInstanceName(metatypeUsedAsAModule)}"` || "that class";
+    return `Classes annotated with @Injectable(), @Catch(), and @Controller() decorators must not appear in the "imports" array of a module.
+Please remove ${metatypeNameQuote} (including forwarded occurrences, if any) from all of the "imports" arrays.
+
+Scope [${stringifyScope(scope)}]
+`;
+};
+exports.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = USING_INVALID_CLASS_AS_A_MODULE_MESSAGE;
+const UNDEFINED_MODULE_MESSAGE = (parentModule, index, scope) => {
+    const parentModuleName = parentModule?.name || "module";
+    return `Venok cannot create the ${parentModuleName} instance.
+The module at index [${index}] of the ${parentModuleName} "imports" array is undefined.
+
+Potential causes:
+- A circular dependency between modules. Use forwardRef() to avoid it.
+- The module at index [${index}] is of type "undefined". Check your import statements and the type of the module.
+
+Scope [${stringifyScope(scope)}]`;
+};
+exports.UNDEFINED_MODULE_MESSAGE = UNDEFINED_MODULE_MESSAGE;
+const UNKNOWN_EXPORT_MESSAGE = (token = "item", module) => {
+    token = (0, shared_helper_1.isSymbol)(token) ? token.toString() : token;
+    return `Venok cannot export a provider/module that is not a part of the currently processed module (${module}). Please verify whether the exported ${token} is available in this particular context.
+
+Possible Solutions:
+- Is ${token} part of the relevant providers/imports within ${module}?
+`;
+};
+exports.UNKNOWN_EXPORT_MESSAGE = UNKNOWN_EXPORT_MESSAGE;
+const INVALID_CLASS_MESSAGE = (text, value) => `ModuleRef cannot instantiate class (${value} is not constructable).`;
+exports.INVALID_CLASS_MESSAGE = INVALID_CLASS_MESSAGE;
+const INVALID_CLASS_SCOPE_MESSAGE = (text, name) => `${name || "This class"} is marked as a scoped provider. Request and transient-scoped providers can't be used in combination with "get()" method. Please, use "resolve()" instead.`;
+exports.INVALID_CLASS_SCOPE_MESSAGE = INVALID_CLASS_SCOPE_MESSAGE;
+exports.UNHANDLED_RUNTIME_EXCEPTION = `Unhandled Runtime Exception.`;
+exports.INVALID_EXCEPTION_FILTER = `Invalid exception filters (@UseFilters()).`;
+exports.MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = `Unable to load @Venok/microservices package. (Please make sure that it's already installed.)`;

package/exceptions/external/filter-context.d.ts

@@ -0,0 +1,10 @@
+import { VenokContainer } from "@venok/core/injector/container";
+import { ApplicationConfig } from "@venok/core/application/config";
+import { BaseExceptionFilterContext } from "@venok/core/exceptions/filter-context";
+import { ExternalExceptionsHandler } from "@venok/core/exceptions/external/handler";
+export declare class ExternalExceptionFilterContext extends BaseExceptionFilterContext {
+    private readonly config?;
+    constructor(container: VenokContainer, config?: ApplicationConfig | undefined);
+    create(instance: object, callback: () => void, module: string, contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): ExternalExceptionsHandler;
+    getGlobalMetadata<T extends any[]>(contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): T;
+}

package/exceptions/external/filter-context.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalExceptionFilterContext = void 0;
+const filter_context_1 = require("@venok/core/exceptions/filter-context");
+const constants_1 = require("@venok/core/injector/constants");
+const constants_2 = require("@venok/core/constants");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const handler_1 = require("@venok/core/exceptions/external/handler");
+class ExternalExceptionFilterContext extends filter_context_1.BaseExceptionFilterContext {
+    constructor(container, config) {
+        super(container);
+        this.config = config;
+    }
+    create(instance, callback, module, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        this.moduleContext = module;
+        const exceptionHandler = new handler_1.ExternalExceptionsHandler();
+        const filters = this.createContext(instance, callback, constants_2.EXCEPTION_FILTERS_METADATA, contextId, inquirerId);
+        if ((0, shared_helper_1.isEmpty)(filters))
+            return exceptionHandler;
+        exceptionHandler.setCustomFilters(filters.reverse());
+        return exceptionHandler;
+    }
+    getGlobalMetadata(contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        if (!this.config)
+            return [];
+        const globalFilters = this.config.getGlobalFilters();
+        if (contextId === constants_1.STATIC_CONTEXT && !inquirerId)
+            return globalFilters;
+        const scopedFilterWrappers = this.config.getGlobalRequestFilters();
+        const scopedFilters = scopedFilterWrappers
+            .map((wrapper) => wrapper.getInstanceByContextId(contextId, inquirerId))
+            .filter((host) => !!host)
+            .map((host) => host.instance);
+        return globalFilters.concat(scopedFilters);
+    }
+}
+exports.ExternalExceptionFilterContext = ExternalExceptionFilterContext;

package/exceptions/external/filter.d.ts

@@ -0,0 +1,5 @@
+import { ArgumentsHost } from "@venok/core/interfaces/context/arguments-host.interface";
+export declare class ExternalExceptionFilter<T = any, R = any> {
+    private static readonly logger;
+    catch(exception: T, host: ArgumentsHost): void;
+}

package/exceptions/external/filter.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalExceptionFilter = void 0;
+const logger_service_1 = require("@venok/core/services/logger.service");
+const exceptions_1 = require("@venok/core/errors/exceptions");
+class ExternalExceptionFilter {
+    catch(exception, host) {
+        if (exception instanceof exceptions_1.RuntimeException) {
+            return ExternalExceptionFilter.logger.error(exception.what(), exception.stack);
+        }
+        if (exception instanceof Error)
+            return ExternalExceptionFilter.logger.error(exception.message, exception.stack);
+    }
+}
+exports.ExternalExceptionFilter = ExternalExceptionFilter;
+ExternalExceptionFilter.logger = new logger_service_1.Logger("ExternalExceptionsHandler");

package/exceptions/external/handler.d.ts

@@ -0,0 +1,9 @@
+import { ExternalExceptionFilter } from "@venok/core/exceptions/external/filter";
+import { ArgumentsHost } from "@venok/core/interfaces/context/arguments-host.interface";
+import { ExceptionFilterMetadata } from "@venok/core/interfaces/features/exception-filter.interface";
+export declare class ExternalExceptionsHandler extends ExternalExceptionFilter {
+    private filters;
+    next(exception: Error | any, host: ArgumentsHost): void | Promise<any>;
+    setCustomFilters(filters: ExceptionFilterMetadata[]): void;
+    invokeCustomFilters<T = any>(exception: T, host: ArgumentsHost): Promise<any> | null;
+}

package/exceptions/external/handler.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalExceptionsHandler = void 0;
+const filter_1 = require("@venok/core/exceptions/external/filter");
+const invalid_exception_filter_exception_1 = require("@venok/core/errors/exceptions/invalid-exception-filter.exception");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const select_exception_filter_metadata_1 = require("@venok/core/exceptions/select-exception-filter-metadata");
+class ExternalExceptionsHandler extends filter_1.ExternalExceptionFilter {
+    constructor() {
+        super(...arguments);
+        this.filters = [];
+    }
+    next(exception, host) {
+        const result = this.invokeCustomFilters(exception, host);
+        if (result)
+            return result;
+        return super.catch(exception, host);
+    }
+    setCustomFilters(filters) {
+        if (!Array.isArray(filters))
+            throw new invalid_exception_filter_exception_1.InvalidExceptionFilterException();
+        this.filters = filters;
+    }
+    invokeCustomFilters(exception, host) {
+        if ((0, shared_helper_1.isEmpty)(this.filters))
+            return null;
+        const filter = (0, select_exception_filter_metadata_1.selectExceptionFilterMetadata)(this.filters, exception);
+        return filter ? filter.func(exception, host) : null;
+    }
+}
+exports.ExternalExceptionsHandler = ExternalExceptionsHandler;

package/exceptions/filter-context.d.ts

@@ -0,0 +1,14 @@
+import { VenokContainer } from "@venok/core/injector/container";
+import { ContextCreator } from "@venok/core/context/creator";
+import { Type } from "@venok/core/interfaces";
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+import { ExceptionFilter } from "@venok/core/interfaces/features/exception-filter.interface";
+export declare class BaseExceptionFilterContext extends ContextCreator {
+    private readonly container;
+    protected moduleContext: string;
+    constructor(container: VenokContainer);
+    createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): R;
+    getFilterInstance(filter: Function | ExceptionFilter, contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): ExceptionFilter | null;
+    getInstanceByMetatype(metatype: Type<unknown>): InstanceWrapper | undefined;
+    reflectCatchExceptions(instance: ExceptionFilter): Type<any>[];
+}

package/exceptions/filter-context.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseExceptionFilterContext = void 0;
+const creator_1 = require("@venok/core/context/creator");
+const constants_1 = require("@venok/core/injector/constants");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const constants_2 = require("@venok/core/constants");
+class BaseExceptionFilterContext extends creator_1.ContextCreator {
+    constructor(container) {
+        super();
+        this.container = container;
+    }
+    createConcreteContext(metadata, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        if ((0, shared_helper_1.isEmpty)(metadata)) {
+            return [];
+        }
+        return metadata
+            .filter((instance) => instance && ((0, shared_helper_1.isFunction)(instance.catch) || instance.name))
+            .map((filter) => this.getFilterInstance(filter, contextId, inquirerId))
+            .filter(Boolean)
+            .map((instance) => ({
+            func: instance.catch.bind(instance),
+            exceptionMetatypes: this.reflectCatchExceptions(instance),
+        }));
+    }
+    getFilterInstance(filter, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        const isObject = filter.catch;
+        // @ts-ignore
+        if (isObject) {
+            return filter;
+        }
+        const instanceWrapper = this.getInstanceByMetatype(filter);
+        if (!instanceWrapper) {
+            return null;
+        }
+        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+        return instanceHost && instanceHost.instance;
+    }
+    getInstanceByMetatype(metatype) {
+        if (!this.moduleContext) {
+            return;
+        }
+        const collection = this.container.getModules();
+        const moduleRef = collection.get(this.moduleContext);
+        if (!moduleRef) {
+            return;
+        }
+        return moduleRef.injectables.get(metatype);
+    }
+    reflectCatchExceptions(instance) {
+        const prototype = Object.getPrototypeOf(instance);
+        return Reflect.getMetadata(constants_2.FILTER_CATCH_EXCEPTIONS, prototype.constructor) || [];
+    }
+}
+exports.BaseExceptionFilterContext = BaseExceptionFilterContext;

package/exceptions/select-exception-filter-metadata.d.ts

@@ -0,0 +1,2 @@
+import { ExceptionFilterMetadata } from "@venok/core/interfaces/features/exception-filter.interface";
+export declare const selectExceptionFilterMetadata: <T = any>(filters: ExceptionFilterMetadata[], exception: T) => ExceptionFilterMetadata | undefined;

package/exceptions/select-exception-filter-metadata.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectExceptionFilterMetadata = void 0;
+const selectExceptionFilterMetadata = (filters, exception) => filters.find(({ exceptionMetatypes }) => !exceptionMetatypes.length ||
+    exceptionMetatypes.some((ExceptionMetaType) => exception instanceof ExceptionMetaType));
+exports.selectExceptionFilterMetadata = selectExceptionFilterMetadata;

package/exceptions/zone/handler.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeException } from "@venok/core/errors/exceptions";
+export declare class ExceptionHandler {
+    private static readonly logger;
+    handle(exception: RuntimeException | Error): void;
+}

package/exceptions/zone/handler.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionHandler = void 0;
+const logger_service_1 = require("@venok/core/services/logger.service");
+const exceptions_1 = require("@venok/core/errors/exceptions");
+class ExceptionHandler {
+    handle(exception) {
+        if (!(exception instanceof exceptions_1.RuntimeException)) {
+            return ExceptionHandler.logger.error(exception.message, exception.stack);
+        }
+        return ExceptionHandler.logger.error(exception.what(), exception.stack);
+    }
+}
+exports.ExceptionHandler = ExceptionHandler;
+ExceptionHandler.logger = new logger_service_1.Logger(ExceptionHandler.name);

package/exceptions/zone/zone.d.ts

@@ -0,0 +1,5 @@
+export declare class ExceptionsZone {
+    private static readonly exceptionHandler;
+    static run(callback: () => void, teardown?: (err: any) => void, autoFlushLogs?: boolean): void;
+    static asyncRun(callback: () => Promise<void>, teardown?: (err: any) => void, autoFlushLogs?: boolean): Promise<void>;
+}

package/exceptions/zone/zone.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionsZone = void 0;
+const handler_1 = require("@venok/core/exceptions/zone/handler");
+const logger_service_1 = require("@venok/core/services/logger.service");
+const DEFAULT_TEARDOWN = () => process.exit(1);
+class ExceptionsZone {
+    static run(callback, teardown = DEFAULT_TEARDOWN, autoFlushLogs) {
+        try {
+            callback();
+        }
+        catch (e) {
+            this.exceptionHandler.handle(e);
+            if (autoFlushLogs)
+                logger_service_1.Logger.flush();
+            teardown(e);
+        }
+    }
+    static async asyncRun(callback, teardown = DEFAULT_TEARDOWN, autoFlushLogs) {
+        try {
+            await callback();
+        }
+        catch (e) {
+            this.exceptionHandler.handle(e);
+            if (autoFlushLogs)
+                logger_service_1.Logger.flush();
+            teardown(e);
+        }
+    }
+}
+exports.ExceptionsZone = ExceptionsZone;
+ExceptionsZone.exceptionHandler = new handler_1.ExceptionHandler();

package/guards/consumer.d.ts

@@ -0,0 +1,9 @@
+import { ContextType } from "@venok/core/interfaces/context/arguments-host.interface";
+import { ExecutionContextHost } from "@venok/core/context/execution-host";
+import { Observable } from "rxjs";
+import { CanActivate } from "@venok/core/interfaces/features/guards.interface";
+export declare class GuardsConsumer {
+    tryActivate<TContext extends string = ContextType>(guards: CanActivate[], args: unknown[], instance: object, callback: (...args: unknown[]) => unknown, type?: TContext): Promise<boolean>;
+    createContext(args: unknown[], instance: object, callback: (...args: unknown[]) => unknown): ExecutionContextHost;
+    pickResult(result: boolean | Promise<boolean> | Observable<boolean>): Promise<boolean>;
+}

package/guards/consumer.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardsConsumer = void 0;
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const execution_host_1 = require("@venok/core/context/execution-host");
+const rxjs_1 = require("rxjs");
+class GuardsConsumer {
+    async tryActivate(guards, args, instance, callback, type) {
+        if (!guards || (0, shared_helper_1.isEmpty)(guards)) {
+            return true;
+        }
+        const context = this.createContext(args, instance, callback);
+        context.setType(type);
+        for (const guard of guards) {
+            const result = guard.canActivate(context);
+            if (await this.pickResult(result)) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+    createContext(args, instance, callback) {
+        return new execution_host_1.ExecutionContextHost(args, instance.constructor, callback);
+    }
+    async pickResult(result) {
+        if (result instanceof rxjs_1.Observable) {
+            return (0, rxjs_1.lastValueFrom)(result);
+        }
+        return result;
+    }
+}
+exports.GuardsConsumer = GuardsConsumer;

package/guards/context-creator.d.ts

@@ -0,0 +1,17 @@
+import { VenokContainer } from "@venok/core/injector/container";
+import { ApplicationConfig } from "@venok/core/application/config";
+import { ContextCreator } from "@venok/core/context/creator";
+import { CanActivate } from "@venok/core/interfaces/features/guards.interface";
+import { Type } from "@venok/core/interfaces";
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+export declare class GuardsContextCreator extends ContextCreator {
+    private readonly container;
+    private readonly config?;
+    private moduleContext;
+    constructor(container: VenokContainer, config?: ApplicationConfig | undefined);
+    create(instance: object, callback: (...args: unknown[]) => unknown, module: string, contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): CanActivate[];
+    createConcreteContext<T extends unknown[], R extends unknown[]>(metadata: T, contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): R;
+    getGuardInstance(metatype: Function | CanActivate, contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): CanActivate | null;
+    getInstanceByMetatype(metatype: Type<unknown>): InstanceWrapper | undefined;
+    getGlobalMetadata<T extends unknown[]>(contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): T;
+}