@venok/core 1.0.0 → 1.0.1-canary.0

package/constants.d.ts

@@ -28,8 +28,6 @@ export declare const APP_FILTER = "APP_FILTER";
 export declare const ENHANCER_TOKEN_TO_SUBTYPE_MAP: Record<typeof APP_GUARD | typeof APP_PIPE | typeof APP_FILTER | typeof APP_INTERCEPTOR, EnhancerSubtype>;
 export declare const REQUEST = "REQUEST";
 export declare const GLOBAL_MODULE_METADATA = "__module:global__";
-export declare const HOST_METADATA = "host";
-export declare const PATH_METADATA = "path";
 export declare const PARAMTYPES_METADATA = "design:paramtypes";
 export declare const SELF_DECLARED_DEPS_METADATA = "self:paramtypes";
 export declare const OPTIONAL_DEPS_METADATA = "optional:paramtypes";

package/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INQUIRER = exports.ENTRY_PROVIDER_WATERMARK = exports.CATCH_WATERMARK = exports.INJECTABLE_WATERMARK = exports.FILTER_CATCH_EXCEPTIONS = exports.CUSTOM_ROUTE_ARGS_METADATA = exports.ROUTE_ARGS_METADATA = exports.MODULE_PATH = exports.SCOPE_OPTIONS_METADATA = exports.OPTIONAL_PROPERTY_DEPS_METADATA = exports.PROPERTY_DEPS_METADATA = exports.OPTIONAL_DEPS_METADATA = exports.SELF_DECLARED_DEPS_METADATA = exports.PARAMTYPES_METADATA = exports.PATH_METADATA = exports.HOST_METADATA = exports.GLOBAL_MODULE_METADATA = exports.REQUEST = exports.ENHANCER_TOKEN_TO_SUBTYPE_MAP = exports.APP_FILTER = exports.APP_GUARD = exports.APP_PIPE = exports.APP_INTERCEPTOR = exports.ENHANCER_KEY_TO_SUBTYPE_MAP = exports.EXCEPTION_FILTERS_METADATA = exports.INTERCEPTORS_METADATA = exports.GUARDS_METADATA = exports.PIPES_METADATA = exports.MODULE_METADATA = exports.FORBIDDEN_MESSAGE = exports.MESSAGES = void 0;
+exports.INQUIRER = exports.ENTRY_PROVIDER_WATERMARK = exports.CATCH_WATERMARK = exports.INJECTABLE_WATERMARK = exports.FILTER_CATCH_EXCEPTIONS = exports.CUSTOM_ROUTE_ARGS_METADATA = exports.ROUTE_ARGS_METADATA = exports.MODULE_PATH = exports.SCOPE_OPTIONS_METADATA = exports.OPTIONAL_PROPERTY_DEPS_METADATA = exports.PROPERTY_DEPS_METADATA = exports.OPTIONAL_DEPS_METADATA = exports.SELF_DECLARED_DEPS_METADATA = exports.PARAMTYPES_METADATA = exports.GLOBAL_MODULE_METADATA = exports.REQUEST = exports.ENHANCER_TOKEN_TO_SUBTYPE_MAP = exports.APP_FILTER = exports.APP_GUARD = exports.APP_PIPE = exports.APP_INTERCEPTOR = exports.ENHANCER_KEY_TO_SUBTYPE_MAP = exports.EXCEPTION_FILTERS_METADATA = exports.INTERCEPTORS_METADATA = exports.GUARDS_METADATA = exports.PIPES_METADATA = exports.MODULE_METADATA = exports.FORBIDDEN_MESSAGE = exports.MESSAGES = void 0;
 exports.MESSAGES = {
     APPLICATION_START: `Starting Venok application...`,
     APPLICATION_READY: `Venok application successfully started`,
@@ -35,8 +35,6 @@ exports.ENHANCER_TOKEN_TO_SUBTYPE_MAP = {
 };
 exports.REQUEST = "REQUEST";
 exports.GLOBAL_MODULE_METADATA = "__module:global__";
-exports.HOST_METADATA = "host";
-exports.PATH_METADATA = "path";
 exports.PARAMTYPES_METADATA = "design:paramtypes";
 exports.SELF_DECLARED_DEPS_METADATA = "self:paramtypes";
 exports.OPTIONAL_DEPS_METADATA = "optional:paramtypes";

package/context/{external/creator.d.ts → context.d.ts}

@@ -1,3 +1,4 @@
+import { Observable } from "rxjs";
 import { ParamData } from "@venok/core/decorators/create-param.decorator";
 import { GuardsConsumer, GuardsContextCreator } from "@venok/core/guards";
 import { InterceptorsConsumer, InterceptorsContextCreator } from "@venok/core/interceptors";
@@ -7,8 +8,9 @@ import { VenokContainer } from "@venok/core/injector/container";
 import { ContextType } from "@venok/core/interfaces/context/arguments-host.interface";
 import { PipeTransform } from "@venok/core/interfaces/features/pipes.interface";
 import { ContextId } from "@venok/core/injector/instance/wrapper";
-import { ParamProperties } from "@venok/core/helpers/context.helper";
-import { ExternalExceptionFilterContext } from "@venok/core/exceptions/external/filter-context";
+import { ContextUtils, ParamProperties } from "@venok/core/helpers/context.helper";
+import { VenokProxy } from "@venok/core/context/proxy";
+import { VenokExceptionFilterContext } from "@venok/core/filters/context";
 export interface ParamsFactory {
     exchangeKeyForValue(type: number, data: ParamData, args: any): any;
 }
@@ -29,8 +31,9 @@ export interface ExternalContextOptions {
     guards?: boolean;
     interceptors?: boolean;
     filters?: boolean;
+    callback?: (result: any | Observable<any>, ...args: any[]) => void;
 }
-export declare class ExternalContextCreator {
+export declare class VenokContextCreator {
     private readonly guardsContextCreator;
     private readonly guardsConsumer;
     private readonly interceptorsContextCreator;
@@ -39,15 +42,15 @@ export declare class ExternalContextCreator {
     private readonly pipesContextCreator;
     private readonly pipesConsumer;
     private readonly filtersContextCreator;
-    private readonly contextUtils;
-    private readonly externalErrorProxy;
+    readonly contextUtils: ContextUtils;
+    readonly venokProxy: VenokProxy;
     private container;
-    constructor(guardsContextCreator: GuardsContextCreator, guardsConsumer: GuardsConsumer, interceptorsContextCreator: InterceptorsContextCreator, interceptorsConsumer: InterceptorsConsumer, modulesContainer: ModulesContainer, pipesContextCreator: PipesContextCreator, pipesConsumer: PipesConsumer, filtersContextCreator: ExternalExceptionFilterContext);
-    static fromContainer(container: VenokContainer): ExternalContextCreator;
+    constructor(guardsContextCreator: GuardsContextCreator, guardsConsumer: GuardsConsumer, interceptorsContextCreator: InterceptorsContextCreator, interceptorsConsumer: InterceptorsConsumer, modulesContainer: ModulesContainer, pipesContextCreator: PipesContextCreator, pipesConsumer: PipesConsumer, filtersContextCreator: VenokExceptionFilterContext);
+    static fromContainer(container: VenokContainer): VenokContextCreator;
     create<TParamsMetadata extends ParamsMetadata = ParamsMetadata, TContext extends string = ContextType>(instance: object, callback: (...args: unknown[]) => unknown, methodName: string, metadataKey?: string, paramsFactory?: ParamsFactory, contextId?: ContextId, inquirerId?: string, options?: ExternalContextOptions, contextType?: TContext): (...args: any[]) => Promise<any>;
     getMetadata<TMetadata, TContext extends string = ContextType>(instance: any, methodName: string, metadataKey?: string, paramsFactory?: ParamsFactory, contextType?: TContext): ExternalHandlerMetadata;
     getContextModuleKey(moduleCtor: Function | undefined): string;
-    exchangeKeysForValues<TMetadata = any>(keys: string[], metadata: TMetadata, moduleContext: string, paramsFactory: ParamsFactory, contextId?: ContextId, inquirerId?: string, contextFactory?: (args: unknown[]) => import("../execution-host").ExecutionContextHost): ParamProperties[];
+    exchangeKeysForValues<TMetadata extends Record<string | symbol, any>>(keys: string[], metadata: TMetadata, moduleContext: string, paramsFactory: ParamsFactory, contextId?: ContextId, inquirerId?: string, contextFactory?: (args: unknown[]) => import("./execution-host").ExecutionContextHost): ParamProperties[];
     createPipesFn(pipes: PipeTransform[], paramsOptions: (ParamProperties & {
         metatype?: unknown;
     })[]): ((args: unknown[], ...params: unknown[]) => Promise<void>) | null;
@@ -56,7 +59,7 @@ export declare class ExternalContextCreator {
         type: any;
         data: any;
     }, pipes: PipeTransform[]): Promise<any>;
-    transformToResult(resultOrDeferred: any): Promise<any>;
+    transformToResult(resultOrDeferred: Observable<any> | any): Promise<any>;
     createGuardsFn<TContext extends string = ContextType>(guards: any[], instance: object, callback: (...args: any[]) => any, contextType?: TContext): Function | null;
     registerRequestProvider<T = any>(request: T, contextId: ContextId): void;
 }

package/context/{external/creator.js → context.js}

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalContextCreator = void 0;
+exports.VenokContextCreator = void 0;
+const rxjs_1 = require("rxjs");
 const guards_1 = require("@venok/core/guards");
 const interceptors_1 = require("@venok/core/interceptors");
 const pipes_1 = require("@venok/core/pipes");
 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 rxjs_1 = require("rxjs");
 const exceptions_1 = require("@venok/core/errors/exceptions");
 const context_helper_1 = require("@venok/core/helpers/context.helper");
-const proxy_1 = require("@venok/core/context/external/proxy");
-const filter_context_1 = require("@venok/core/exceptions/external/filter-context");
-class ExternalContextCreator {
+const proxy_1 = require("@venok/core/context/proxy");
+const context_1 = require("@venok/core/filters/context");
+class VenokContextCreator {
     constructor(guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, modulesContainer, pipesContextCreator, pipesConsumer, filtersContextCreator) {
         this.guardsContextCreator = guardsContextCreator;
         this.guardsConsumer = guardsConsumer;
@@ -23,7 +23,7 @@ class ExternalContextCreator {
         this.pipesConsumer = pipesConsumer;
         this.filtersContextCreator = filtersContextCreator;
         this.contextUtils = new context_helper_1.ContextUtils();
-        this.externalErrorProxy = new proxy_1.ExternalErrorProxy();
+        this.venokProxy = new proxy_1.VenokProxy();
     }
     static fromContainer(container) {
         const guardsContextCreator = new guards_1.GuardsContextCreator(container, container.applicationConfig);
@@ -32,16 +32,17 @@ class ExternalContextCreator {
         const interceptorsConsumer = new interceptors_1.InterceptorsConsumer();
         const pipesContextCreator = new pipes_1.PipesContextCreator(container, container.applicationConfig);
         const pipesConsumer = new pipes_1.PipesConsumer();
-        const filtersContextCreator = new filter_context_1.ExternalExceptionFilterContext(container, container.applicationConfig);
-        const externalContextCreator = new ExternalContextCreator(guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, container.getModules(), pipesContextCreator, pipesConsumer, filtersContextCreator);
-        externalContextCreator.container = container;
-        return externalContextCreator;
+        const filtersContextCreator = new context_1.VenokExceptionFilterContext(container, container.applicationConfig);
+        const venokContextCreator = new VenokContextCreator(guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, container.getModules(), pipesContextCreator, pipesConsumer, filtersContextCreator);
+        venokContextCreator.container = container;
+        return venokContextCreator;
     }
     create(instance, callback, methodName, metadataKey, paramsFactory, contextId = constants_1.STATIC_CONTEXT, inquirerId, options = {
         interceptors: true,
         guards: true,
         filters: true,
-    }, contextType = "http") {
+        callback: () => { },
+    }, contextType = "native") {
         const module = this.getContextModuleKey(instance.constructor);
         const { argsLength, paramtypes, getParamsMetadata } = this.getMetadata(instance, methodName, metadataKey, paramsFactory, contextType);
         const pipes = this.pipesContextCreator.create(instance, callback, module, contextId, inquirerId);
@@ -65,9 +66,12 @@ class ExternalContextCreator {
             const initialArgs = this.contextUtils.createNullArray(argsLength);
             fnCanActivate && (await fnCanActivate(args));
             const result = await this.interceptorsConsumer.intercept(interceptors, args, instance, callback, handler(initialArgs, ...args), contextType);
-            return this.transformToResult(result);
+            const done = await this.transformToResult(result);
+            if (options.callback)
+                options.callback(done, ...args);
+            return done;
         };
-        return options.filters ? this.externalErrorProxy.createProxy(target, exceptionFilter, contextType) : target;
+        return options.filters ? this.venokProxy.createProxy(target, exceptionFilter, contextType) : target;
     }
     getMetadata(instance, methodName, metadataKey, paramsFactory, contextType) {
         // const cacheMetadata = this.handlerMetadataStorage.get(instance, methodName);
@@ -92,28 +96,23 @@ class ExternalContextCreator {
     }
     getContextModuleKey(moduleCtor) {
         const emptyModuleKey = "";
-        if (!moduleCtor) {
+        if (!moduleCtor)
             return emptyModuleKey;
-        }
         const moduleContainerEntries = this.modulesContainer.entries();
         for (const [key, moduleRef] of moduleContainerEntries) {
-            if (moduleRef.hasProvider(moduleCtor)) {
+            // REFACTOR
+            if (moduleRef.hasProvider && moduleRef.hasProvider(moduleCtor))
                 return key;
-            }
         }
         return emptyModuleKey;
     }
     exchangeKeysForValues(keys, metadata, moduleContext, paramsFactory, contextId = constants_1.STATIC_CONTEXT, inquirerId, contextFactory = this.contextUtils.getContextFactory("http")) {
         this.pipesContextCreator.setModuleContext(moduleContext);
         return keys.map((key) => {
-            // Maybe Error
-            // @ts-ignore
             const { index, data, pipes: pipesCollection } = metadata[key];
             const pipes = this.pipesContextCreator.createConcreteContext(pipesCollection, contextId, inquirerId);
             const type = this.contextUtils.mapParamType(key);
             if (key.includes(constants_2.CUSTOM_ROUTE_ARGS_METADATA)) {
-                // Maybe Error
-                // @ts-ignore
                 const { factory } = metadata[key];
                 const customExtractValue = this.contextUtils.getCustomFactory(factory, data, contextFactory);
                 return { index, extractValue: customExtractValue, type, data, pipes };
@@ -138,17 +137,15 @@ class ExternalContextCreator {
         return (0, shared_helper_1.isEmpty)(pipes) ? value : this.pipesConsumer.apply(value, { metatype, type, data }, pipes);
     }
     async transformToResult(resultOrDeferred) {
-        if ((0, rxjs_1.isObservable)(resultOrDeferred)) {
+        if ((0, rxjs_1.isObservable)(resultOrDeferred))
             return (0, rxjs_1.lastValueFrom)(resultOrDeferred);
-        }
         return resultOrDeferred;
     }
     createGuardsFn(guards, instance, callback, contextType) {
         const canActivateFn = async (args) => {
             const canActivate = await this.guardsConsumer.tryActivate(guards, args, instance, callback, contextType);
-            if (!canActivate) {
+            if (!canActivate)
                 throw new exceptions_1.RuntimeException(constants_2.FORBIDDEN_MESSAGE);
-            }
         };
         return guards.length ? canActivateFn : null;
     }
@@ -156,4 +153,4 @@ class ExternalContextCreator {
         this.container.registerRequestProvider(request, contextId);
     }
 }
-exports.ExternalContextCreator = ExternalContextCreator;
+exports.VenokContextCreator = VenokContextCreator;

package/context/execution-host.d.ts

@@ -6,7 +6,7 @@ export declare class ExecutionContextHost implements ExecutionContext {
     private readonly constructorRef;
     private readonly handler;
     private contextType;
-    constructor(args: any[], constructorRef?: Type<any>, handler?: Function);
+    constructor(args: any[], constructorRef?: Type, handler?: Function);
     setType<TContext extends string = ContextType>(type: TContext): void;
     getType<TContext extends string = ContextType>(): TContext;
     getClass<T = any>(): Type<T>;

package/context/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./context";
+export * from "./creator";
+export * from "./execution-host";
+export * from "./proxy";

package/context/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./context"), exports);
+__exportStar(require("./creator"), exports);
+__exportStar(require("./execution-host"), exports);
+__exportStar(require("./proxy"), exports);

package/context/proxy.d.ts

@@ -0,0 +1,6 @@
+import { ContextType } from "@venok/core/interfaces";
+import { VenokExceptionsHandler } from "@venok/core/exceptions/handler";
+export declare class VenokProxy {
+    createProxy<TContext extends string = ContextType>(targetCallback: (...args: any[]) => any, exceptionsHandler: VenokExceptionsHandler, type?: TContext): (...args: any[]) => Promise<any>;
+    createExceptionLayerProxy<TContext extends string = ContextType>(targetCallback: <TError>(err: TError, ...args: any[]) => void, exceptionsHandler: VenokExceptionsHandler, type?: TContext): <TError>(err: TError, ...args: any[]) => Promise<any[] | undefined>;
+}

package/context/proxy.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VenokProxy = void 0;
+const execution_host_1 = require("@venok/core/context/execution-host");
+class VenokProxy {
+    createProxy(targetCallback, exceptionsHandler, type) {
+        return async (...args) => {
+            try {
+                return await targetCallback(...args);
+            }
+            catch (e) {
+                const host = new execution_host_1.ExecutionContextHost(args);
+                host.setType(type);
+                exceptionsHandler.next(e, host);
+                return args;
+            }
+        };
+    }
+    createExceptionLayerProxy(targetCallback, exceptionsHandler, type) {
+        return async (err, ...args) => {
+            try {
+                await targetCallback(err, ...args);
+            }
+            catch (e) {
+                const host = new execution_host_1.ExecutionContextHost(args);
+                host.setType(type);
+                exceptionsHandler.next(e, host);
+                return args;
+            }
+        };
+    }
+}
+exports.VenokProxy = VenokProxy;

package/decorators/catch.decorator.d.ts

@@ -14,4 +14,4 @@ import { Abstract, Type } from "@venok/core/interfaces";
  *
  * @publicApi
  */
-export declare function Catch(...exceptions: Array<Type<any> | Abstract<any>>): ClassDecorator;
+export declare function Catch(...exceptions: Array<Type | Abstract<any>>): ClassDecorator;

package/errors/exceptions/invalid-class-scope.exception.d.ts

@@ -1,5 +1,5 @@
 import { RuntimeException } from "./runtime.exception";
 import { Abstract, Type } from "@venok/core/interfaces";
 export declare class InvalidClassScopeException extends RuntimeException {
-    constructor(metatypeOrToken: Type<any> | Abstract<any> | string | symbol);
+    constructor(metatypeOrToken: Type | Abstract<any> | string | symbol);
 }

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

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

package/errors/messages.d.ts

@@ -3,7 +3,7 @@ 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 UNDEFINED_FORWARDREF_MESSAGE: (scope: Type[]) => 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;

package/exceptions/handler.d.ts

@@ -0,0 +1,10 @@
+import { ArgumentsHost, ExceptionFilter, ExceptionFilterMetadata } from "@venok/core";
+export declare class VenokExceptionsHandler {
+    private readonly exceptionsFilter;
+    private filters;
+    constructor(exceptionsFilter: ExceptionFilter);
+    next(exception: Error | any, host: ArgumentsHost): any;
+    setCustomFilters(filters: ExceptionFilterMetadata[]): void;
+    invokeCustomFilters<T = any>(exception: T, host: ArgumentsHost): boolean;
+    protected selectExceptionFilterMetadata<T = any>(filters: ExceptionFilterMetadata[], exception: T): ExceptionFilterMetadata | undefined;
+}

package/exceptions/{external/handler.js → handler.js}

@@ -1,20 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalExceptionsHandler = void 0;
-const filter_1 = require("@venok/core/exceptions/external/filter");
+exports.VenokExceptionsHandler = void 0;
 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);
+class VenokExceptionsHandler {
+    constructor(exceptionsFilter) {
+        this.exceptionsFilter = exceptionsFilter;
         this.filters = [];
     }
     next(exception, host) {
         const result = this.invokeCustomFilters(exception, host);
         if (result)
             return result;
-        return super.catch(exception, host);
+        return this.exceptionsFilter.catch(exception, host);
     }
     setCustomFilters(filters) {
         if (!Array.isArray(filters))
@@ -23,9 +21,14 @@ class ExternalExceptionsHandler extends filter_1.ExternalExceptionFilter {
     }
     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;
+            return false;
+        const filter = this.selectExceptionFilterMetadata(this.filters, exception);
+        filter && filter.func(exception, host);
+        return !!filter;
+    }
+    selectExceptionFilterMetadata(filters, exception) {
+        return filters.find(({ exceptionMetatypes }) => !exceptionMetatypes.length ||
+            exceptionMetatypes.some((ExceptionMetaType) => exception instanceof ExceptionMetaType));
     }
 }
-exports.ExternalExceptionsHandler = ExternalExceptionsHandler;
+exports.VenokExceptionsHandler = VenokExceptionsHandler;

package/exceptions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./zone";
+export * from "./handler";

package/exceptions/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./zone"), exports);
+__exportStar(require("./handler"), exports);

package/exceptions/zone/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./handler";
+export * from "./zone";

package/exceptions/zone/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./handler"), exports);
+__exportStar(require("./zone"), exports);

package/{exceptions/filter-context.d.ts → filters/context-creator.d.ts}

@@ -3,12 +3,12 @@ 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 {
+export declare class ExceptionFilterContextCreator 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>[];
+    getInstanceByMetatype(metatype: Type): InstanceWrapper | undefined;
+    reflectCatchExceptions(instance: ExceptionFilter): Type[];
 }

package/{exceptions/filter-context.js → filters/context-creator.js}

@@ -1,19 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseExceptionFilterContext = void 0;
+exports.ExceptionFilterContextCreator = 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 {
+class ExceptionFilterContextCreator 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)) {
+        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))
@@ -24,27 +23,21 @@ class BaseExceptionFilterContext extends creator_1.ContextCreator {
         }));
     }
     getFilterInstance(filter, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
-        const isObject = filter.catch;
-        // @ts-ignore
-        if (isObject) {
+        if ("catch" in filter)
             return filter;
-        }
         const instanceWrapper = this.getInstanceByMetatype(filter);
-        if (!instanceWrapper) {
+        if (!instanceWrapper)
             return null;
-        }
         const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
         return instanceHost && instanceHost.instance;
     }
     getInstanceByMetatype(metatype) {
-        if (!this.moduleContext) {
+        if (!this.moduleContext)
             return;
-        }
         const collection = this.container.getModules();
         const moduleRef = collection.get(this.moduleContext);
-        if (!moduleRef) {
+        if (!moduleRef)
             return;
-        }
         return moduleRef.injectables.get(metatype);
     }
     reflectCatchExceptions(instance) {
@@ -52,4 +45,4 @@ class BaseExceptionFilterContext extends creator_1.ContextCreator {
         return Reflect.getMetadata(constants_2.FILTER_CATCH_EXCEPTIONS, prototype.constructor) || [];
     }
 }
-exports.BaseExceptionFilterContext = BaseExceptionFilterContext;
+exports.ExceptionFilterContextCreator = ExceptionFilterContextCreator;

package/filters/context.d.ts

@@ -0,0 +1,12 @@
+import { VenokContainer } from "@venok/core/injector/container";
+import { ApplicationConfig } from "@venok/core/application/config";
+import { ExceptionFilterContextCreator } from "@venok/core/filters/context-creator";
+import { ExceptionFilter } from "@venok/core/interfaces/features/exception-filter.interface";
+import { VenokExceptionsHandler } from "@venok/core/exceptions/handler";
+export declare class VenokExceptionFilterContext extends ExceptionFilterContextCreator {
+    private readonly config?;
+    constructor(container: VenokContainer, config?: ApplicationConfig | undefined);
+    create(instance: object, callback: (...args: any) => void, module: string, contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): VenokExceptionsHandler;
+    getExceptionFilter(): ExceptionFilter;
+    getGlobalMetadata<T extends any[]>(contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): T;
+}

package/{exceptions/external/filter-context.js → filters/context.js}

@@ -1,25 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalExceptionFilterContext = void 0;
-const filter_context_1 = require("@venok/core/exceptions/filter-context");
+exports.VenokExceptionFilterContext = void 0;
+const context_creator_1 = require("@venok/core/filters/context-creator");
 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 {
+const handler_1 = require("@venok/core/exceptions/handler");
+const filter_1 = require("@venok/core/filters/filter");
+class VenokExceptionFilterContext extends context_creator_1.ExceptionFilterContextCreator {
     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 exceptionHandler = new handler_1.VenokExceptionsHandler(this.getExceptionFilter());
         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;
     }
+    getExceptionFilter() {
+        return new filter_1.VenokExceptionFilter();
+    }
     getGlobalMetadata(contextId = constants_1.STATIC_CONTEXT, inquirerId) {
         if (!this.config)
             return [];
@@ -34,4 +38,4 @@ class ExternalExceptionFilterContext extends filter_context_1.BaseExceptionFilte
         return globalFilters.concat(scopedFilters);
     }
 }
-exports.ExternalExceptionFilterContext = ExternalExceptionFilterContext;
+exports.VenokExceptionFilterContext = VenokExceptionFilterContext;

package/filters/filter.d.ts

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

package/filters/filter.js

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

package/filters/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./context";
+export * from "./context-creator";
+export * from "./filter";

package/filters/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./context"), exports);
+__exportStar(require("./context-creator"), exports);
+__exportStar(require("./filter"), exports);

package/guards/context-creator.d.ts

@@ -12,6 +12,6 @@ export declare class GuardsContextCreator extends ContextCreator {
     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;
+    getInstanceByMetatype(metatype: Type): InstanceWrapper | undefined;
     getGlobalMetadata<T extends unknown[]>(contextId?: import("@venok/core/injector/instance/wrapper").ContextId, inquirerId?: string): T;
 }