@venok/http 1.1.0 → 2.0.0

package/exceptions/messages.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.INVALID_MIDDLEWARE_MESSAGE = exports.INVALID_MIDDLEWARE_CONFIGURATION = exports.UNKNOWN_REQUEST_MAPPING = void 0;
-const UNKNOWN_REQUEST_MAPPING = (metatype) => {
-    const className = metatype.name;
-    return className
-        ? `An invalid controller has been detected. "${className}" does not have the @Controller() decorator but it is being listed in the "controllers" array of some module.`
-        : `An invalid controller has been detected. Perhaps, one of your controllers is missing the @Controller() decorator.`;
-};
-exports.UNKNOWN_REQUEST_MAPPING = UNKNOWN_REQUEST_MAPPING;
-exports.INVALID_MIDDLEWARE_CONFIGURATION = `An invalid middleware configuration has been passed inside the module 'configure()' method.`;
-const INVALID_MIDDLEWARE_MESSAGE = (text, name) => `The middleware doesn't provide the 'use' method (${name})`;
-exports.INVALID_MIDDLEWARE_MESSAGE = INVALID_MIDDLEWARE_MESSAGE;

package/explorers/path.explorer.d.ts

@@ -1,8 +0,0 @@
-import { MetadataScanner } from "@venok/core";
-import { RouteDefinition } from "../interfaces";
-export declare class PathsExplorer {
-    private readonly metadataScanner;
-    constructor(metadataScanner: MetadataScanner);
-    scanForPaths(instance: Object, prototype?: object): RouteDefinition[];
-    exploreMethodMetadata<T extends Record<string | symbol, any>>(instance: T, prototype: T, methodName: string): RouteDefinition | null;
-}

package/explorers/path.explorer.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PathsExplorer = void 0;
-const shared_helper_1 = require("../../core/helpers/shared.helper");
-const constants_1 = require("../constants");
-const helpers_1 = require("../helpers");
-class PathsExplorer {
-    constructor(metadataScanner) {
-        this.metadataScanner = metadataScanner;
-    }
-    scanForPaths(instance, prototype) {
-        const instancePrototype = (0, shared_helper_1.isUndefined)(prototype) ? Object.getPrototypeOf(instance) : prototype;
-        return this.metadataScanner.getAllMethodNames(instancePrototype).reduce((acc, method) => {
-            const route = this.exploreMethodMetadata(instance, instancePrototype, method);
-            if (route)
-                acc.push(route);
-            return acc;
-        }, []);
-    }
-    exploreMethodMetadata(instance, prototype, methodName) {
-        const instanceCallback = instance[methodName];
-        const prototypeCallback = prototype[methodName];
-        const routePath = Reflect.getMetadata(constants_1.PATH_METADATA, prototypeCallback);
-        if ((0, shared_helper_1.isUndefined)(routePath))
-            return null;
-        const requestMethod = Reflect.getMetadata(constants_1.METHOD_METADATA, prototypeCallback);
-        const version = Reflect.getMetadata(constants_1.VERSION_METADATA, prototypeCallback);
-        const path = (0, shared_helper_1.isString)(routePath) ? [(0, helpers_1.addLeadingSlash)(routePath)] : routePath.map((p) => (0, helpers_1.addLeadingSlash)(p));
-        return {
-            path,
-            requestMethod,
-            targetCallback: instanceCallback,
-            methodName,
-            version,
-        };
-    }
-}
-exports.PathsExplorer = PathsExplorer;

package/explorers/router.explorer.d.ts

@@ -1,51 +0,0 @@
-import { ApplicationConfig, ContextId, MetadataScanner, Type, VenokContainer } from "@venok/core";
-import { RequestMethod } from "../enums";
-import { HttpServer, RouteDefinition, RoutePathMetadata, VersionValue } from "../interfaces";
-import { RoutePathFactory } from "../factory";
-import { Injector } from "@venok/core/injector/injector";
-import { GraphInspector } from "@venok/core/inspector/graph-inspector";
-import { AbstractHttpAdapter } from "../adapter/adapter";
-import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
-import { Module } from "@venok/core/injector/module/module";
-import { RouterExceptionFiltersContext } from "../filters/context";
-import { VenokProxy } from "@venok/core/context";
-import { VenokExceptionsHandler } from "@venok/core/exceptions/handler";
-export interface ExceptionsFilter {
-    create(instance: Object, callback: Function, module: string, contextId?: ContextId, inquirerId?: string): VenokExceptionsHandler;
-}
-export type HttpEntrypointMetadata = {
-    path: string;
-    requestMethod: keyof typeof RequestMethod;
-    methodVersion?: VersionValue;
-    controllerVersion?: VersionValue;
-};
-export type MiddlewareEntrypointMetadata = {
-    path: string;
-    requestMethod: keyof typeof RequestMethod;
-    version?: VersionValue;
-};
-export declare class RouterExplorer {
-    private readonly container;
-    private readonly injector;
-    private readonly routerProxy;
-    private readonly exceptionsFilter;
-    private readonly routePathFactory;
-    private readonly graphInspector;
-    private readonly applicationRef;
-    private readonly httpContextCreator;
-    private readonly pathsExplorer;
-    private readonly routerMethodFactory;
-    private readonly logger;
-    private readonly exceptionFiltersCache;
-    constructor(metadataScanner: MetadataScanner, container: VenokContainer, injector: Injector, routerProxy: VenokProxy, exceptionsFilter: RouterExceptionFiltersContext, config: ApplicationConfig, routePathFactory: RoutePathFactory, graphInspector: GraphInspector, applicationRef: AbstractHttpAdapter);
-    explore<T extends HttpServer = any>(instanceWrapper: InstanceWrapper, moduleKey: string, applicationRef: T, host: string | RegExp | Array<string | RegExp>, routePathMetadata: RoutePathMetadata): void;
-    extractRouterPath(metatype: Type<Object>): string[];
-    applyPathsToRouterProxy<T extends HttpServer>(router: T, routeDefinitions: RouteDefinition[], instanceWrapper: InstanceWrapper, moduleKey: string, routePathMetadata: RoutePathMetadata, host: string | RegExp | Array<string | RegExp>): void;
-    private applyCallbackToRouter;
-    private applyHostFilter;
-    private applyVersionFilter;
-    private createCallbackProxy;
-    createRequestScopedHandler(instanceWrapper: InstanceWrapper, requestMethod: RequestMethod, moduleRef: Module, moduleKey: string, methodName: string): <TRequest extends Record<any, any>, TResponse>(req: TRequest, res: TResponse, next: () => void) => Promise<void>;
-    private getContextId;
-    private copyMetadataToCallback;
-}

package/explorers/router.explorer.js

@@ -1,195 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterExplorer = void 0;
-const enums_1 = require("../enums");
-const path_explorer_1 = require("./path.explorer");
-const factory_1 = require("../factory");
-const logger_service_1 = require("../../core/services/logger.service");
-const pipes_1 = require("../../core/pipes");
-const guards_1 = require("../../core/guards");
-const interceptors_1 = require("../../core/interceptors");
-const constants_1 = require("../constants");
-const shared_helper_1 = require("../../core/helpers/shared.helper");
-const helpers_1 = require("../helpers");
-const path_to_regexp_1 = require("path-to-regexp");
-const errors_1 = require("../errors");
-const constants_2 = require("../../core/injector/constants");
-const execution_host_1 = require("../../core/context/execution-host");
-const context_1 = require("../../core/context");
-const context_2 = require("../context/context");
-class RouterExplorer {
-    constructor(metadataScanner, container, injector, routerProxy, exceptionsFilter, config, routePathFactory, graphInspector, applicationRef) {
-        this.container = container;
-        this.injector = injector;
-        this.routerProxy = routerProxy;
-        this.exceptionsFilter = exceptionsFilter;
-        this.routePathFactory = routePathFactory;
-        this.graphInspector = graphInspector;
-        this.applicationRef = applicationRef;
-        this.routerMethodFactory = new factory_1.RouterMethodFactory();
-        this.logger = new logger_service_1.Logger(RouterExplorer.name, {
-            timestamp: true,
-        });
-        this.exceptionFiltersCache = new WeakMap();
-        this.pathsExplorer = new path_explorer_1.PathsExplorer(metadataScanner);
-        this.httpContextCreator = new context_2.HttpContextCreator(context_1.VenokContextCreator.fromContainer(container), this.exceptionsFilter, this.applicationRef);
-        const routeParamsFactory = new factory_1.RouteParamsFactory();
-        const pipesContextCreator = new pipes_1.PipesContextCreator(container, config);
-        const pipesConsumer = new pipes_1.PipesConsumer();
-        const guardsContextCreator = new guards_1.GuardsContextCreator(container, config);
-        const guardsConsumer = new guards_1.GuardsConsumer();
-        const interceptorsContextCreator = new interceptors_1.InterceptorsContextCreator(container, config);
-        const interceptorsConsumer = new interceptors_1.InterceptorsConsumer();
-    }
-    explore(instanceWrapper, moduleKey, applicationRef, host, routePathMetadata) {
-        const { instance } = instanceWrapper;
-        const routerPaths = this.pathsExplorer.scanForPaths(instance);
-        this.applyPathsToRouterProxy(applicationRef, routerPaths, instanceWrapper, moduleKey, routePathMetadata, host);
-    }
-    extractRouterPath(metatype) {
-        const path = Reflect.getMetadata(constants_1.PATH_METADATA, metatype);
-        if ((0, shared_helper_1.isUndefined)(path))
-            return [];
-        if (Array.isArray(path))
-            return path.map((p) => (0, helpers_1.addLeadingSlash)(p));
-        return [(0, helpers_1.addLeadingSlash)(path)];
-    }
-    applyPathsToRouterProxy(router, routeDefinitions, instanceWrapper, moduleKey, routePathMetadata, host) {
-        (routeDefinitions || []).forEach((routeDefinition) => {
-            const { version: methodVersion } = routeDefinition;
-            routePathMetadata.methodVersion = methodVersion;
-            this.applyCallbackToRouter(router, routeDefinition, instanceWrapper, moduleKey, routePathMetadata, host);
-        });
-    }
-    applyCallbackToRouter(router, routeDefinition, instanceWrapper, moduleKey, routePathMetadata, host) {
-        const { path: paths, requestMethod, targetCallback, methodName } = routeDefinition;
-        const { instance } = instanceWrapper;
-        const routerMethodRef = this.routerMethodFactory.get(router, requestMethod).bind(router);
-        const isRequestScoped = !instanceWrapper.isDependencyTreeStatic();
-        const proxy = isRequestScoped
-            ? this.createRequestScopedHandler(instanceWrapper, requestMethod, this.container.getModuleByKey(moduleKey), moduleKey, methodName)
-            : this.createCallbackProxy(instance, targetCallback, methodName, moduleKey, requestMethod);
-        const isVersioned = (routePathMetadata.methodVersion || routePathMetadata.controllerVersion) && routePathMetadata.versioningOptions;
-        let routeHandler = this.applyHostFilter(host, proxy);
-        paths.forEach((path) => {
-            if (isVersioned && routePathMetadata.versioningOptions.type !== enums_1.VersioningType.URI) {
-                // All versioning (except for URI Versioning) is done via the "Version Filter"
-                routeHandler = this.applyVersionFilter(router, routePathMetadata, routeHandler);
-            }
-            routePathMetadata.methodPath = path;
-            const pathsToRegister = this.routePathFactory.create(routePathMetadata, requestMethod);
-            pathsToRegister.forEach((path) => {
-                const entrypointDefinition = {
-                    type: "http-endpoint",
-                    methodName,
-                    className: instanceWrapper.name,
-                    classNodeId: instanceWrapper.id,
-                    metadata: {
-                        key: path,
-                        path,
-                        requestMethod: enums_1.RequestMethod[requestMethod],
-                        methodVersion: routePathMetadata.methodVersion,
-                        controllerVersion: routePathMetadata.controllerVersion,
-                    },
-                };
-                this.copyMetadataToCallback(targetCallback, routeHandler);
-                routerMethodRef(path, routeHandler);
-                this.graphInspector.insertEntrypointDefinition(entrypointDefinition, instanceWrapper.id);
-            });
-            const pathsToLog = this.routePathFactory.create({
-                ...routePathMetadata,
-                versioningOptions: undefined,
-            }, requestMethod);
-            pathsToLog.forEach((path) => {
-                if (isVersioned) {
-                    const version = this.routePathFactory.getVersion(routePathMetadata);
-                    this.logger.log((0, helpers_1.VERSIONED_ROUTE_MAPPED_MESSAGE)(path, requestMethod, version));
-                }
-                else {
-                    this.logger.log((0, helpers_1.ROUTE_MAPPED_MESSAGE)(path, requestMethod));
-                }
-            });
-        });
-    }
-    applyHostFilter(host, handler) {
-        if (!host)
-            return handler;
-        const hosts = Array.isArray(host) ? host : [host];
-        const hostRegExps = hosts.map((host) => {
-            const keys = [];
-            const regexp = (0, path_to_regexp_1.pathToRegexp)(host, keys);
-            return { regexp, keys };
-        });
-        const unsupportedFilteringErrorMessage = Array.isArray(host)
-            ? `HTTP adapter does not support filtering on hosts: ["${host.join('", "')}"]`
-            : `HTTP adapter does not support filtering on host: "${host}"`;
-        return (req, res, next) => {
-            req.hosts = {};
-            const hostname = this.applicationRef.getRequestHostname(req) || "";
-            for (const exp of hostRegExps) {
-                const match = hostname.match(exp.regexp);
-                if (match) {
-                    if (exp.keys.length > 0) {
-                        exp.keys.forEach((key, i) => (req.hosts[key.name] = match[i + 1]));
-                    }
-                    else if (exp.regexp && match.groups) {
-                        for (const groupName in match.groups)
-                            req.hosts[groupName] = match.groups[groupName];
-                    }
-                    return handler(req, res, next);
-                }
-            }
-            if (!next)
-                throw new errors_1.InternalServerErrorException(unsupportedFilteringErrorMessage);
-            return next();
-        };
-    }
-    applyVersionFilter(router, routePathMetadata, handler) {
-        const version = this.routePathFactory.getVersion(routePathMetadata);
-        return router.applyVersionFilter(handler, version, routePathMetadata.versioningOptions);
-    }
-    createCallbackProxy(instance, callback, methodName, moduleRef, requestMethod, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
-        return this.httpContextCreator.create(instance, callback, methodName, moduleRef, requestMethod, contextId, inquirerId);
-    }
-    createRequestScopedHandler(instanceWrapper, requestMethod, moduleRef, moduleKey, methodName) {
-        const { instance } = instanceWrapper;
-        const collection = moduleRef.injectables;
-        const isTreeDurable = instanceWrapper.isDependencyTreeDurable();
-        return async (req, res, next) => {
-            try {
-                const contextId = this.getContextId(req, isTreeDurable);
-                const contextInstance = await this.injector.loadPerContext(instance, moduleRef, collection, contextId);
-                await this.createCallbackProxy(contextInstance, contextInstance[methodName], methodName, moduleKey, requestMethod, contextId, instanceWrapper.id)(req, res, next);
-            }
-            catch (err) {
-                let exceptionFilter = this.exceptionFiltersCache.get(instance[methodName]);
-                if (!exceptionFilter) {
-                    exceptionFilter = this.exceptionsFilter.create(instance, instance[methodName], moduleKey);
-                    this.exceptionFiltersCache.set(instance[methodName], exceptionFilter);
-                }
-                const host = new execution_host_1.ExecutionContextHost([req, res, next]);
-                exceptionFilter.next(err, host);
-            }
-        };
-    }
-    getContextId(request, isTreeDurable) {
-        const contextId = factory_1.ContextIdFactory.getByRequest(request);
-        if (!request[constants_1.REQUEST_CONTEXT_ID]) {
-            Object.defineProperty(request, constants_1.REQUEST_CONTEXT_ID, {
-                value: contextId,
-                enumerable: false,
-                writable: false,
-                configurable: false,
-            });
-            const requestProviderValue = isTreeDurable ? contextId.payload : request;
-            this.container.registerRequestProvider(requestProviderValue, contextId);
-        }
-        return contextId;
-    }
-    copyMetadataToCallback(originalCallback, targetCallback) {
-        for (const key of Reflect.getMetadataKeys(originalCallback)) {
-            Reflect.defineMetadata(key, Reflect.getMetadata(key, originalCallback), targetCallback);
-        }
-    }
-}
-exports.RouterExplorer = RouterExplorer;

package/factory/context-id.factory.d.ts

@@ -1,41 +0,0 @@
-import { ContextId, HostComponentInfo } from "@venok/core";
-export type ContextIdResolverFn = (info: HostComponentInfo) => ContextId;
-export interface ContextIdResolver {
-    /**
-     * Payload associated with the custom context id
-     */
-    payload: unknown;
-    /**
-     * A context id resolver function
-     */
-    resolve: ContextIdResolverFn;
-}
-export interface ContextIdStrategy<T = any> {
-    /**
-     * Allows to attach a parent context id to the existing child context id.
-     * This lets you construct durable DI subtrees that can be shared between contexts.
-     * @param contextId auto-generated child context id
-     * @param request request object
-     */
-    attach(contextId: ContextId, request: T): ContextIdResolverFn | ContextIdResolver | undefined;
-}
-export declare class ContextIdFactory {
-    private static strategy?;
-    /**
-     * Generates a context identifier based on the request object.
-     */
-    static create(): ContextId;
-    /**
-     * Generates a random identifier to track asynchronous execution context.
-     * @param request request object
-     * @param propsToInspect
-     */
-    static getByRequest<T extends Record<any, any> = any>(request: T, propsToInspect?: string[]): ContextId;
-    /**
-     * Registers a custom context id strategy that lets you attach
-     * a parent context id to the existing context id object.
-     * @param strategy strategy instance
-     */
-    static apply(strategy: ContextIdStrategy): void;
-    private static isContextIdResolverWithPayload;
-}

package/factory/context-id.factory.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextIdFactory = void 0;
-const constants_1 = require("@venok/http/constants");
-const context_id_factory_helper_1 = require("../../core/helpers/context-id-factory.helper");
-const shared_helper_1 = require("../../core/helpers/shared.helper");
-class ContextIdFactory {
-    /**
-     * Generates a context identifier based on the request object.
-     */
-    static create() {
-        return (0, context_id_factory_helper_1.createContextId)();
-    }
-    /**
-     * Generates a random identifier to track asynchronous execution context.
-     * @param request request object
-     * @param propsToInspect
-     */
-    static getByRequest(request, propsToInspect = ["raw"]) {
-        if (!request)
-            return ContextIdFactory.create();
-        if (request[constants_1.REQUEST_CONTEXT_ID])
-            return request[constants_1.REQUEST_CONTEXT_ID];
-        for (const key of propsToInspect)
-            if (request[key]?.[constants_1.REQUEST_CONTEXT_ID])
-                return request[key][constants_1.REQUEST_CONTEXT_ID];
-        if (!this.strategy)
-            return ContextIdFactory.create();
-        const contextId = (0, context_id_factory_helper_1.createContextId)();
-        const resolverObjectOrFunction = this.strategy.attach(contextId, request);
-        if (this.isContextIdResolverWithPayload(resolverObjectOrFunction)) {
-            contextId.getParent = resolverObjectOrFunction.resolve;
-            contextId.payload = resolverObjectOrFunction.payload;
-        }
-        else {
-            contextId.getParent = resolverObjectOrFunction;
-        }
-        return contextId;
-    }
-    /**
-     * Registers a custom context id strategy that lets you attach
-     * a parent context id to the existing context id object.
-     * @param strategy strategy instance
-     */
-    static apply(strategy) {
-        this.strategy = strategy;
-    }
-    static isContextIdResolverWithPayload(resolverOrResolverFn) {
-        return (0, shared_helper_1.isObject)(resolverOrResolverFn);
-    }
-}
-exports.ContextIdFactory = ContextIdFactory;

package/factory/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./context-id.factory";
-export * from "./method.factory";
-export * from "./params.factory";
-export * from "./path.factory";

package/factory/index.js

@@ -1,20 +0,0 @@
-"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-id.factory"), exports);
-__exportStar(require("./method.factory"), exports);
-__exportStar(require("./params.factory"), exports);
-__exportStar(require("./path.factory"), exports);

package/factory/method.factory.d.ts

@@ -1,5 +0,0 @@
-import { HttpServer } from "../interfaces";
-import { RequestMethod } from "../enums";
-export declare class RouterMethodFactory {
-    get(target: HttpServer, requestMethod: RequestMethod): Function;
-}

package/factory/method.factory.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterMethodFactory = void 0;
-const enums_1 = require("../enums");
-class RouterMethodFactory {
-    get(target, requestMethod) {
-        switch (requestMethod) {
-            case enums_1.RequestMethod.POST:
-                return target.post;
-            case enums_1.RequestMethod.ALL:
-                return target.all;
-            case enums_1.RequestMethod.DELETE:
-                return target.delete;
-            case enums_1.RequestMethod.PUT:
-                return target.put;
-            case enums_1.RequestMethod.PATCH:
-                return target.patch;
-            case enums_1.RequestMethod.OPTIONS:
-                return target.options;
-            case enums_1.RequestMethod.HEAD:
-                return target.head;
-            case enums_1.RequestMethod.GET:
-                return target.get;
-            default: {
-                return target.use;
-            }
-        }
-    }
-}
-exports.RouterMethodFactory = RouterMethodFactory;

package/factory/params.factory.d.ts

@@ -1,5 +0,0 @@
-import { RouteParamtypes } from "../enums";
-import { IRouteParamsFactory } from "../context/context";
-export declare class RouteParamsFactory implements IRouteParamsFactory {
-    exchangeKeyForValue<TRequest extends Record<string, any> = any, TResponse = any, TResult = any>(key: RouteParamtypes | string, data: string | object | any, args: [TRequest, TResponse, Function]): TResult;
-}

package/factory/params.factory.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteParamsFactory = void 0;
-const enums_1 = require("../enums");
-class RouteParamsFactory {
-    exchangeKeyForValue(key, data, args) {
-        const [req, res, next] = args;
-        switch (key) {
-            case enums_1.RouteParamtypes.NEXT:
-                return next;
-            case enums_1.RouteParamtypes.REQUEST:
-                return req;
-            case enums_1.RouteParamtypes.RESPONSE:
-                return res;
-            case enums_1.RouteParamtypes.BODY:
-                return data && req.body ? req.body[data] : req.body;
-            case enums_1.RouteParamtypes.PARAM:
-                return data ? req.params[data] : req.params;
-            case enums_1.RouteParamtypes.HOST:
-                const hosts = req.hosts || {};
-                return data ? hosts[data] : hosts;
-            case enums_1.RouteParamtypes.QUERY:
-                return data ? req.query[data] : req.query;
-            case enums_1.RouteParamtypes.HEADERS:
-                return data ? req.headers[data.toLowerCase()] : req.headers;
-            case enums_1.RouteParamtypes.SESSION:
-                return req.session;
-            case enums_1.RouteParamtypes.FILE:
-                return req[data || "file"];
-            case enums_1.RouteParamtypes.FILES:
-                return req.files;
-            case enums_1.RouteParamtypes.IP:
-                return req.ip;
-            default:
-                return null;
-        }
-    }
-}
-exports.RouteParamsFactory = RouteParamsFactory;

package/factory/path.factory.d.ts

@@ -1,13 +0,0 @@
-import { HttpConfig } from "../application/config";
-import { RoutePathMetadata, VersioningOptions, VersionValue } from "../interfaces";
-import { RequestMethod } from "../enums";
-export declare class RoutePathFactory {
-    private readonly config;
-    constructor(config: HttpConfig);
-    create(metadata: RoutePathMetadata, requestMethod?: RequestMethod): string[];
-    getVersion(metadata: RoutePathMetadata): VersionValue | undefined;
-    getVersionPrefix(versioningOptions: VersioningOptions): string;
-    appendToAllIfDefined(paths: string[], fragmentToAppend: string | string[] | undefined): string[];
-    isExcludedFromGlobalPrefix(path: string, requestMethod?: RequestMethod, versionOrVersions?: VersionValue, versioningOptions?: VersioningOptions): boolean;
-    private truncateVersionPrefixFromPath;
-}

package/factory/path.factory.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoutePathFactory = void 0;
-const interfaces_1 = require("../interfaces");
-const enums_1 = require("../enums");
-const flatten_helper_1 = require("../../core/helpers/flatten.helper");
-const helpers_1 = require("../helpers");
-const shared_helper_1 = require("../../core/helpers/shared.helper");
-class RoutePathFactory {
-    constructor(config) {
-        this.config = config;
-    }
-    create(metadata, requestMethod) {
-        let paths = [""];
-        const versionOrVersions = this.getVersion(metadata);
-        if (versionOrVersions && metadata.versioningOptions?.type === enums_1.VersioningType.URI) {
-            const versionPrefix = this.getVersionPrefix(metadata.versioningOptions);
-            if (Array.isArray(versionOrVersions)) {
-                paths = (0, flatten_helper_1.flatten)(paths.map((path) => versionOrVersions.map((version) => 
-                // Version Neutral - Do not include version in URL
-                version === interfaces_1.VERSION_NEUTRAL ? path : `${path}/${versionPrefix}${version}`)));
-            }
-            else {
-                // Version Neutral - Do not include version in URL
-                if (versionOrVersions !== interfaces_1.VERSION_NEUTRAL) {
-                    paths = paths.map((path) => `${path}/${versionPrefix}${versionOrVersions}`);
-                }
-            }
-        }
-        paths = this.appendToAllIfDefined(paths, metadata.modulePath);
-        paths = this.appendToAllIfDefined(paths, metadata.ctrlPath);
-        paths = this.appendToAllIfDefined(paths, metadata.methodPath);
-        if (metadata.globalPrefix) {
-            paths = paths.map((path) => {
-                if (this.isExcludedFromGlobalPrefix(path, requestMethod, versionOrVersions, metadata.versioningOptions)) {
-                    return path;
-                }
-                return (0, helpers_1.stripEndSlash)(metadata.globalPrefix || "") + path;
-            });
-        }
-        return paths.map((path) => (0, helpers_1.addLeadingSlash)(path || "/")).map((path) => (path !== "/" ? (0, helpers_1.stripEndSlash)(path) : path));
-    }
-    getVersion(metadata) {
-        // The version will be either the path version or the controller version,
-        // with the pathVersion taking priority.
-        return metadata.methodVersion || metadata.controllerVersion;
-    }
-    getVersionPrefix(versioningOptions) {
-        const defaultPrefix = "v";
-        if (versioningOptions.type === enums_1.VersioningType.URI) {
-            if (versioningOptions.prefix === false) {
-                return "";
-            }
-            else if (versioningOptions.prefix !== undefined) {
-                return versioningOptions.prefix;
-            }
-        }
-        return defaultPrefix;
-    }
-    appendToAllIfDefined(paths, fragmentToAppend) {
-        if (!fragmentToAppend) {
-            return paths;
-        }
-        const concatPaths = (a, b) => (0, helpers_1.stripEndSlash)(a) + (0, helpers_1.addLeadingSlash)(b);
-        if (Array.isArray(fragmentToAppend)) {
-            const paths2dArray = paths.map((path) => fragmentToAppend.map((fragment) => concatPaths(path, fragment)));
-            return (0, flatten_helper_1.flatten)(paths2dArray);
-        }
-        return paths.map((path) => concatPaths(path, fragmentToAppend));
-    }
-    isExcludedFromGlobalPrefix(path, requestMethod, versionOrVersions, versioningOptions) {
-        if ((0, shared_helper_1.isUndefined)(requestMethod)) {
-            return false;
-        }
-        const options = this.config.getGlobalPrefixOptions();
-        const excludedRoutes = options.exclude;
-        if (versionOrVersions && versionOrVersions !== interfaces_1.VERSION_NEUTRAL && versioningOptions?.type === enums_1.VersioningType.URI) {
-            path = this.truncateVersionPrefixFromPath(path, versionOrVersions, versioningOptions);
-        }
-        return Array.isArray(excludedRoutes) && (0, helpers_1.isRouteExcluded)(excludedRoutes, path, requestMethod);
-    }
-    truncateVersionPrefixFromPath(path, versionValue, versioningOptions) {
-        if (typeof versionValue !== "string") {
-            versionValue.forEach((version) => {
-                if (typeof version === "string") {
-                    path = this.truncateVersionPrefixFromPath(path, version, versioningOptions);
-                }
-            });
-            return path;
-        }
-        const prefix = `/${this.getVersionPrefix(versioningOptions)}${versionValue}`;
-        return path.startsWith(prefix) ? path.replace(prefix, "") : path;
-    }
-}
-exports.RoutePathFactory = RoutePathFactory;

package/filters/context.d.ts

@@ -1,9 +0,0 @@
-import { ApplicationConfig, VenokContainer } from "@venok/core";
-import { HttpServer } from "../interfaces";
-import { HttpExceptionFilter } from "./filter";
-import { VenokExceptionFilterContext } from "@venok/core/filters/context";
-export declare class RouterExceptionFiltersContext extends VenokExceptionFilterContext {
-    private readonly applicationRef;
-    constructor(container: VenokContainer, config: ApplicationConfig, applicationRef: HttpServer);
-    getExceptionFilter(): HttpExceptionFilter<any>;
-}

package/filters/context.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouterExceptionFiltersContext = void 0;
-const filter_1 = require("./filter");
-const context_1 = require("../../core/filters/context");
-class RouterExceptionFiltersContext extends context_1.VenokExceptionFilterContext {
-    constructor(container, config, applicationRef) {
-        super(container, config);
-        this.applicationRef = applicationRef;
-    }
-    getExceptionFilter() {
-        return new filter_1.HttpExceptionFilter(this.applicationRef);
-    }
-}
-exports.RouterExceptionFiltersContext = RouterExceptionFiltersContext;