@venok/core 1.0.0

package/application/factory.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VenokFactory = exports.VenokFactoryStatic = void 0;
+const container_1 = require("@venok/core/injector/container");
+const config_1 = require("@venok/core/application/config");
+const logger_service_1 = require("@venok/core/services/logger.service");
+const context_1 = require("@venok/core/application/context");
+const graph_inspector_1 = require("@venok/core/inspector/graph-inspector");
+const uuid_helper_1 = require("@venok/core/helpers/uuid.helper");
+const injector_1 = require("@venok/core/injector/injector");
+const loader_1 = require("@venok/core/injector/instance/loader");
+const metadata_scanner_1 = require("@venok/core/metadata-scanner");
+const scanner_1 = require("@venok/core/scanner");
+const zone_1 = require("@venok/core/exceptions/zone/zone");
+const constants_1 = require("@venok/core/constants");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const noop_graph_inspector_1 = require("@venok/core/inspector/noop-graph-inspector");
+const rethrow_helper_1 = require("@venok/core/helpers/rethrow.helper");
+/**
+ * @publicApi
+ */
+class VenokFactoryStatic {
+    constructor() {
+        this.logger = new logger_service_1.Logger("VenokFactory", {
+            timestamp: true,
+        });
+        this.abortOnError = true;
+        this.autoFlushLogs = false;
+    }
+    /**
+     * 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.
+     */
+    async createApplicationContext(moduleCls, options) {
+        const applicationConfig = new config_1.ApplicationConfig();
+        const container = new container_1.VenokContainer(applicationConfig);
+        const graphInspector = this.createGraphInspector(options, container);
+        this.setAbortOnError(options);
+        this.registerLoggerConfiguration(options);
+        await this.initialize(moduleCls, container, graphInspector, applicationConfig, options);
+        const modules = container.getModules().values();
+        const root = modules.next().value;
+        const context = this.createVenokInstance(new context_1.ApplicationContext(container, applicationConfig, options, root));
+        if (this.autoFlushLogs) {
+            context.flushLogsOnOverride();
+        }
+        // return context.init();
+        return context;
+    }
+    createVenokInstance(instance) {
+        return this.createProxy(instance);
+    }
+    setAbortOnError(options) {
+        this.abortOnError = !(options && options.abortOnError === false);
+    }
+    async initialize(module, container, graphInspector, config = new config_1.ApplicationConfig(), options = {}) {
+        uuid_helper_1.UuidFactory.mode = options.snapshot ? uuid_helper_1.UuidFactoryMode.Deterministic : uuid_helper_1.UuidFactoryMode.Random;
+        const injector = new injector_1.Injector({ preview: options.preview });
+        const instanceLoader = new loader_1.InstanceLoader(container, injector, graphInspector);
+        const metadataScanner = new metadata_scanner_1.MetadataScanner();
+        const dependenciesScanner = new scanner_1.DependenciesScanner(container, metadataScanner, graphInspector, config);
+        // Maybe Error
+        const teardown = !this.abortOnError ? rethrow_helper_1.rethrow : undefined;
+        try {
+            this.logger.log(constants_1.MESSAGES.APPLICATION_START);
+            await zone_1.ExceptionsZone.asyncRun(async () => {
+                await dependenciesScanner.scan(module);
+                await instanceLoader.createInstancesOfDependencies();
+                dependenciesScanner.applyApplicationProviders();
+            }, teardown, this.autoFlushLogs);
+        }
+        catch (e) {
+            this.handleInitializationError(e);
+        }
+    }
+    handleInitializationError(err) {
+        if (this.abortOnError) {
+            process.abort();
+        }
+        (0, rethrow_helper_1.rethrow)(err);
+    }
+    createProxy(target) {
+        const proxy = this.createExceptionProxy();
+        return new Proxy(target, {
+            get: proxy,
+            set: proxy,
+        });
+    }
+    createExceptionProxy() {
+        return (receiver, prop) => {
+            if (!(prop in receiver)) {
+                return;
+            }
+            if ((0, shared_helper_1.isFunction)(receiver[prop])) {
+                return this.createExceptionZone(receiver, prop);
+            }
+            return receiver[prop];
+        };
+    }
+    createExceptionZone(receiver, prop) {
+        // Maybe Error
+        const teardown = !this.abortOnError ? rethrow_helper_1.rethrow : undefined;
+        return (...args) => {
+            let result;
+            zone_1.ExceptionsZone.run(() => {
+                result = receiver[prop](...args);
+            }, teardown);
+            return result;
+        };
+    }
+    registerLoggerConfiguration(options) {
+        if (!options) {
+            return;
+        }
+        const { logger, bufferLogs, autoFlushLogs } = options;
+        if (!!logger && !(0, shared_helper_1.isNull)(logger)) {
+            logger_service_1.Logger.overrideLogger(logger);
+        }
+        if (bufferLogs) {
+            logger_service_1.Logger.attachBuffer();
+        }
+        this.autoFlushLogs = autoFlushLogs ?? true;
+    }
+    createGraphInspector(appOptions, container) {
+        return appOptions?.snapshot ? new graph_inspector_1.GraphInspector(container) : noop_graph_inspector_1.NoopGraphInspector;
+    }
+}
+exports.VenokFactoryStatic = VenokFactoryStatic;
+/**
+ * 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
+ */
+exports.VenokFactory = new VenokFactoryStatic();

package/constants.d.ts

@@ -0,0 +1,46 @@
+export declare const MESSAGES: {
+    APPLICATION_START: string;
+    APPLICATION_READY: string;
+    UNKNOWN_EXCEPTION_MESSAGE: string;
+    ERROR_DURING_SHUTDOWN: string;
+};
+export declare const FORBIDDEN_MESSAGE = "Forbidden resource";
+export declare const MODULE_METADATA: {
+    IMPORTS: string;
+    PROVIDERS: string;
+    EXPORTS: string;
+};
+export declare const PIPES_METADATA = "__pipes__";
+export declare const GUARDS_METADATA = "__guards__";
+export declare const INTERCEPTORS_METADATA = "__interceptors__";
+export declare const EXCEPTION_FILTERS_METADATA = "__exceptionFilters__";
+export declare const ENHANCER_KEY_TO_SUBTYPE_MAP: {
+    readonly __guards__: "guard";
+    readonly __interceptors__: "interceptor";
+    readonly __pipes__: "pipe";
+    readonly __exceptionFilters__: "filter";
+};
+export type EnhancerSubtype = (typeof ENHANCER_KEY_TO_SUBTYPE_MAP)[keyof typeof ENHANCER_KEY_TO_SUBTYPE_MAP];
+export declare const APP_INTERCEPTOR = "APP_INTERCEPTOR";
+export declare const APP_PIPE = "APP_PIPE";
+export declare const APP_GUARD = "APP_GUARD";
+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";
+export declare const PROPERTY_DEPS_METADATA = "self:properties_metadata";
+export declare const OPTIONAL_PROPERTY_DEPS_METADATA = "optional:properties_metadata";
+export declare const SCOPE_OPTIONS_METADATA = "scope:options";
+export declare const MODULE_PATH = "__module_path__";
+export declare const ROUTE_ARGS_METADATA = "__routeArguments__";
+export declare const CUSTOM_ROUTE_ARGS_METADATA = "__customRouteArgs__";
+export declare const FILTER_CATCH_EXCEPTIONS = "__filterCatchExceptions__";
+export declare const INJECTABLE_WATERMARK = "__injectable__";
+export declare const CATCH_WATERMARK = "__catch__";
+export declare const ENTRY_PROVIDER_WATERMARK = "__entryProvider__";
+export declare const INQUIRER = "INQUIRER";

package/constants.js

@@ -0,0 +1,53 @@
+"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.MESSAGES = {
+    APPLICATION_START: `Starting Venok application...`,
+    APPLICATION_READY: `Venok application successfully started`,
+    UNKNOWN_EXCEPTION_MESSAGE: "Internal server error",
+    ERROR_DURING_SHUTDOWN: "Error happened during shutdown",
+};
+exports.FORBIDDEN_MESSAGE = "Forbidden resource";
+exports.MODULE_METADATA = {
+    IMPORTS: "imports",
+    PROVIDERS: "providers",
+    EXPORTS: "exports",
+};
+exports.PIPES_METADATA = "__pipes__";
+exports.GUARDS_METADATA = "__guards__";
+exports.INTERCEPTORS_METADATA = "__interceptors__";
+exports.EXCEPTION_FILTERS_METADATA = "__exceptionFilters__";
+exports.ENHANCER_KEY_TO_SUBTYPE_MAP = {
+    [exports.GUARDS_METADATA]: "guard",
+    [exports.INTERCEPTORS_METADATA]: "interceptor",
+    [exports.PIPES_METADATA]: "pipe",
+    [exports.EXCEPTION_FILTERS_METADATA]: "filter",
+};
+exports.APP_INTERCEPTOR = "APP_INTERCEPTOR";
+exports.APP_PIPE = "APP_PIPE";
+exports.APP_GUARD = "APP_GUARD";
+exports.APP_FILTER = "APP_FILTER";
+exports.ENHANCER_TOKEN_TO_SUBTYPE_MAP = {
+    [exports.APP_GUARD]: "guard",
+    [exports.APP_INTERCEPTOR]: "interceptor",
+    [exports.APP_PIPE]: "pipe",
+    [exports.APP_FILTER]: "filter",
+};
+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";
+exports.PROPERTY_DEPS_METADATA = "self:properties_metadata";
+exports.OPTIONAL_PROPERTY_DEPS_METADATA = "optional:properties_metadata";
+exports.SCOPE_OPTIONS_METADATA = "scope:options";
+exports.MODULE_PATH = "__module_path__";
+exports.ROUTE_ARGS_METADATA = "__routeArguments__";
+exports.CUSTOM_ROUTE_ARGS_METADATA = "__customRouteArgs__";
+exports.FILTER_CATCH_EXCEPTIONS = "__filterCatchExceptions__";
+exports.INJECTABLE_WATERMARK = "__injectable__";
+exports.CATCH_WATERMARK = "__catch__";
+exports.ENTRY_PROVIDER_WATERMARK = "__entryProvider__";
+exports.INQUIRER = "INQUIRER";

package/context/creator.d.ts

@@ -0,0 +1,9 @@
+import { ContextId, InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+export declare abstract class ContextCreator {
+    abstract createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: ContextId, inquirerId?: string): R;
+    getGlobalMetadata?<T extends any[]>(contextId?: ContextId, inquirerId?: string): T;
+    createContext<T extends unknown[] = any, R extends unknown[] = any>(instance: object, callback: (...args: any[]) => void, metadataKey: string, contextId?: ContextId, inquirerId?: string): R;
+    reflectClassMetadata<T>(instance: object, metadataKey: string): T;
+    reflectMethodMetadata<T>(callback: (...args: unknown[]) => unknown, metadataKey: string): T;
+    protected getContextId(contextId: ContextId, instanceWrapper: InstanceWrapper): ContextId;
+}

package/context/creator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextCreator = void 0;
+const constants_1 = require("@venok/core/injector/constants");
+class ContextCreator {
+    createContext(instance, callback, metadataKey, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        const globalMetadata = this.getGlobalMetadata && this.getGlobalMetadata(contextId, inquirerId);
+        const classMetadata = this.reflectClassMetadata(instance, metadataKey);
+        const methodMetadata = this.reflectMethodMetadata(callback, metadataKey);
+        return [
+            ...this.createConcreteContext(globalMetadata || [], contextId, inquirerId),
+            ...this.createConcreteContext(classMetadata, contextId, inquirerId),
+            ...this.createConcreteContext(methodMetadata, contextId, inquirerId),
+        ];
+    }
+    reflectClassMetadata(instance, metadataKey) {
+        const prototype = Object.getPrototypeOf(instance);
+        return Reflect.getMetadata(metadataKey, prototype.constructor);
+    }
+    reflectMethodMetadata(callback, metadataKey) {
+        return Reflect.getMetadata(metadataKey, callback);
+    }
+    getContextId(contextId, instanceWrapper) {
+        return contextId.getParent
+            ? contextId.getParent({
+                token: instanceWrapper.token,
+                isTreeDurable: instanceWrapper.isDependencyTreeDurable(),
+            })
+            : contextId;
+    }
+}
+exports.ContextCreator = ContextCreator;

package/context/execution-host.d.ts

@@ -0,0 +1,16 @@
+import { Type } from "@venok/core/interfaces";
+import { ExecutionContext } from "@venok/core/interfaces/context/execution.interface";
+import { ContextType } from "@venok/core/interfaces/context/arguments-host.interface";
+export declare class ExecutionContextHost implements ExecutionContext {
+    private readonly args;
+    private readonly constructorRef;
+    private readonly handler;
+    private contextType;
+    constructor(args: any[], constructorRef?: Type<any>, handler?: Function);
+    setType<TContext extends string = ContextType>(type: TContext): void;
+    getType<TContext extends string = ContextType>(): TContext;
+    getClass<T = any>(): Type<T>;
+    getHandler(): Function;
+    getArgs<T extends Array<any> = any[]>(): T;
+    getArgByIndex<T = any>(index: number): T;
+}

package/context/execution-host.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionContextHost = void 0;
+class ExecutionContextHost {
+    constructor(args, constructorRef = null, handler = null) {
+        this.args = args;
+        this.constructorRef = constructorRef;
+        this.handler = handler;
+        this.contextType = "native";
+    }
+    setType(type) {
+        type && (this.contextType = type);
+    }
+    getType() {
+        return this.contextType;
+    }
+    getClass() {
+        return this.constructorRef;
+    }
+    getHandler() {
+        return this.handler;
+    }
+    getArgs() {
+        return this.args;
+    }
+    getArgByIndex(index) {
+        return this.args[index];
+    }
+}
+exports.ExecutionContextHost = ExecutionContextHost;

package/context/external/creator.d.ts

@@ -0,0 +1,63 @@
+import { ParamData } from "@venok/core/decorators/create-param.decorator";
+import { GuardsConsumer, GuardsContextCreator } from "@venok/core/guards";
+import { InterceptorsConsumer, InterceptorsContextCreator } from "@venok/core/interceptors";
+import { ModulesContainer } from "@venok/core/injector/module/container";
+import { PipesConsumer, PipesContextCreator } from "@venok/core/pipes";
+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";
+export interface ParamsFactory {
+    exchangeKeyForValue(type: number, data: ParamData, args: any): any;
+}
+export type ParamsMetadata = Record<number, ParamMetadata>;
+export interface ParamMetadata {
+    index: number;
+    data?: ParamData;
+}
+type ParamPropertiesWithMetatype<T = any> = ParamProperties & {
+    metatype?: T;
+};
+export interface ExternalHandlerMetadata {
+    argsLength: number;
+    paramtypes: any[];
+    getParamsMetadata: (moduleKey: string, contextId?: ContextId, inquirerId?: string) => ParamPropertiesWithMetatype[];
+}
+export interface ExternalContextOptions {
+    guards?: boolean;
+    interceptors?: boolean;
+    filters?: boolean;
+}
+export declare class ExternalContextCreator {
+    private readonly guardsContextCreator;
+    private readonly guardsConsumer;
+    private readonly interceptorsContextCreator;
+    private readonly interceptorsConsumer;
+    private readonly modulesContainer;
+    private readonly pipesContextCreator;
+    private readonly pipesConsumer;
+    private readonly filtersContextCreator;
+    private readonly contextUtils;
+    private readonly externalErrorProxy;
+    private container;
+    constructor(guardsContextCreator: GuardsContextCreator, guardsConsumer: GuardsConsumer, interceptorsContextCreator: InterceptorsContextCreator, interceptorsConsumer: InterceptorsConsumer, modulesContainer: ModulesContainer, pipesContextCreator: PipesContextCreator, pipesConsumer: PipesConsumer, filtersContextCreator: ExternalExceptionFilterContext);
+    static fromContainer(container: VenokContainer): ExternalContextCreator;
+    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[];
+    createPipesFn(pipes: PipeTransform[], paramsOptions: (ParamProperties & {
+        metatype?: unknown;
+    })[]): ((args: unknown[], ...params: unknown[]) => Promise<void>) | null;
+    getParamValue<T>(value: T, { metatype, type, data }: {
+        metatype: any;
+        type: any;
+        data: any;
+    }, pipes: PipeTransform[]): Promise<any>;
+    transformToResult(resultOrDeferred: 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;
+}
+export {};

package/context/external/creator.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalContextCreator = void 0;
+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 {
+    constructor(guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, modulesContainer, pipesContextCreator, pipesConsumer, filtersContextCreator) {
+        this.guardsContextCreator = guardsContextCreator;
+        this.guardsConsumer = guardsConsumer;
+        this.interceptorsContextCreator = interceptorsContextCreator;
+        this.interceptorsConsumer = interceptorsConsumer;
+        this.modulesContainer = modulesContainer;
+        this.pipesContextCreator = pipesContextCreator;
+        this.pipesConsumer = pipesConsumer;
+        this.filtersContextCreator = filtersContextCreator;
+        this.contextUtils = new context_helper_1.ContextUtils();
+        this.externalErrorProxy = new proxy_1.ExternalErrorProxy();
+    }
+    static fromContainer(container) {
+        const guardsContextCreator = new guards_1.GuardsContextCreator(container, container.applicationConfig);
+        const guardsConsumer = new guards_1.GuardsConsumer();
+        const interceptorsContextCreator = new interceptors_1.InterceptorsContextCreator(container, container.applicationConfig);
+        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;
+    }
+    create(instance, callback, methodName, metadataKey, paramsFactory, contextId = constants_1.STATIC_CONTEXT, inquirerId, options = {
+        interceptors: true,
+        guards: true,
+        filters: true,
+    }, contextType = "http") {
+        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);
+        const guards = this.guardsContextCreator.create(instance, callback, module, contextId, inquirerId);
+        const exceptionFilter = this.filtersContextCreator.create(instance, callback, module, contextId, inquirerId);
+        const interceptors = options.interceptors
+            ? this.interceptorsContextCreator.create(instance, callback, module, contextId, inquirerId)
+            : [];
+        const paramsMetadata = getParamsMetadata(module, contextId, inquirerId);
+        const paramsOptions = paramsMetadata ? this.contextUtils.mergeParamsMetatypes(paramsMetadata, paramtypes) : [];
+        const fnCanActivate = options.guards ? this.createGuardsFn(guards, instance, callback, contextType) : null;
+        const fnApplyPipes = this.createPipesFn(pipes, paramsOptions);
+        const handler = (initialArgs, ...args) => async () => {
+            if (fnApplyPipes) {
+                await fnApplyPipes(initialArgs, ...args);
+                return callback.apply(instance, initialArgs);
+            }
+            return callback.apply(instance, args);
+        };
+        const target = async (...args) => {
+            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);
+        };
+        return options.filters ? this.externalErrorProxy.createProxy(target, exceptionFilter, contextType) : target;
+    }
+    getMetadata(instance, methodName, metadataKey, paramsFactory, contextType) {
+        // const cacheMetadata = this.handlerMetadataStorage.get(instance, methodName);
+        // if (cacheMetadata) {
+        //   return cacheMetadata;
+        // }
+        const metadata = this.contextUtils.reflectCallbackMetadata(instance, methodName, metadataKey || "") || {};
+        const keys = Object.keys(metadata);
+        const argsLength = this.contextUtils.getArgumentsLength(keys, metadata);
+        const paramtypes = this.contextUtils.reflectCallbackParamtypes(instance, methodName);
+        const contextFactory = this.contextUtils.getContextFactory(contextType, instance, instance[methodName]);
+        const getParamsMetadata = (moduleKey, contextId = constants_1.STATIC_CONTEXT, inquirerId) => paramsFactory
+            ? this.exchangeKeysForValues(keys, metadata, moduleKey, paramsFactory, contextId, inquirerId, contextFactory)
+            : null;
+        const handlerMetadata = {
+            argsLength,
+            paramtypes,
+            getParamsMetadata,
+        };
+        // this.handlerMetadataStorage.set(instance, methodName, handlerMetadata);
+        return handlerMetadata;
+    }
+    getContextModuleKey(moduleCtor) {
+        const emptyModuleKey = "";
+        if (!moduleCtor) {
+            return emptyModuleKey;
+        }
+        const moduleContainerEntries = this.modulesContainer.entries();
+        for (const [key, moduleRef] of moduleContainerEntries) {
+            if (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 };
+            }
+            const numericType = Number(type);
+            const extractValue = (...args) => paramsFactory.exchangeKeyForValue(numericType, data, args);
+            return { index, extractValue, type: numericType, data, pipes };
+        });
+    }
+    createPipesFn(pipes, paramsOptions) {
+        const pipesFn = async (args, ...params) => {
+            const resolveParamValue = async (param) => {
+                const { index, extractValue, type, data, metatype, pipes: paramPipes } = param;
+                const value = extractValue(...params);
+                args[index] = await this.getParamValue(value, { metatype, type, data }, pipes.concat(paramPipes));
+            };
+            await Promise.all(paramsOptions.map(resolveParamValue));
+        };
+        return paramsOptions.length ? pipesFn : null;
+    }
+    async getParamValue(value, { metatype, type, data }, pipes) {
+        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)) {
+            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) {
+                throw new exceptions_1.RuntimeException(constants_2.FORBIDDEN_MESSAGE);
+            }
+        };
+        return guards.length ? canActivateFn : null;
+    }
+    registerRequestProvider(request, contextId) {
+        this.container.registerRequestProvider(request, contextId);
+    }
+}
+exports.ExternalContextCreator = ExternalContextCreator;

package/context/external/proxy.d.ts

@@ -0,0 +1,5 @@
+import { ContextType } from "@venok/core/interfaces/context/arguments-host.interface";
+import { ExternalExceptionsHandler } from "@venok/core/exceptions/external/handler";
+export declare class ExternalErrorProxy {
+    createProxy<TContext extends string = ContextType>(targetCallback: (...args: any[]) => any, exceptionsHandler: ExternalExceptionsHandler, type?: TContext): (...args: any[]) => Promise<any>;
+}

package/context/external/proxy.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalErrorProxy = void 0;
+const execution_host_1 = require("@venok/core/context/execution-host");
+class ExternalErrorProxy {
+    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);
+                return exceptionsHandler.next(e, host);
+            }
+        };
+    }
+}
+exports.ExternalErrorProxy = ExternalErrorProxy;

package/decorators/apply.decorator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Function that returns a new decorator that applies all decorators provided by param
+ *
+ * Useful to build new decorators (or a decorator factory) encapsulating multiple decorators related with the same feature
+ *
+ * @param decorators one or more decorators (e.g., `ApplyGuard(...)`)
+ *
+ * @publicApi
+ */
+export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;

package/decorators/apply.decorator.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDecorators = void 0;
+/**
+ * Function that returns a new decorator that applies all decorators provided by param
+ *
+ * Useful to build new decorators (or a decorator factory) encapsulating multiple decorators related with the same feature
+ *
+ * @param decorators one or more decorators (e.g., `ApplyGuard(...)`)
+ *
+ * @publicApi
+ */
+function applyDecorators(...decorators) {
+    return (target, propertyKey, descriptor) => {
+        for (const decorator of decorators) {
+            if (target instanceof Function && !descriptor) {
+                decorator(target);
+                continue;
+            }
+            decorator(target, propertyKey, descriptor);
+        }
+    };
+}
+exports.applyDecorators = applyDecorators;

package/decorators/bind.decorator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Decorator that binds *parameter decorators* to the method that follows.
+ *
+ * Useful when the language doesn't provide a 'Parameter Decorator' feature
+ * (i.e., vanilla JavaScript).
+ *
+ * @param decorators one or more parameter decorators (e.g., `Req()`)
+ *
+ * @publicApi
+ */
+export declare function Bind(...decorators: any[]): MethodDecorator;

package/decorators/bind.decorator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bind = void 0;
+/**
+ * Decorator that binds *parameter decorators* to the method that follows.
+ *
+ * Useful when the language doesn't provide a 'Parameter Decorator' feature
+ * (i.e., vanilla JavaScript).
+ *
+ * @param decorators one or more parameter decorators (e.g., `Req()`)
+ *
+ * @publicApi
+ */
+function Bind(...decorators) {
+    return (target, key, descriptor) => {
+        decorators.forEach((fn, index) => fn(target, key, index));
+        return descriptor;
+    };
+}
+exports.Bind = Bind;