@venok/http 1.0.1-canary.0

package/errors/not-found.exception.d.ts

@@ -0,0 +1,33 @@
+import { HttpException, HttpExceptionOptions } from "./http.exception";
+/**
+ * Defines an HTTP exception for *Not Found* type errors.
+ *
+ * @publicApi
+ */
+export declare class NotFoundException extends HttpException {
+    /**
+     * Instantiate a `NotFoundException` Exception.
+     *
+     * @example
+     * `throw new NotFoundException()`
+     *
+     * @usageNotes
+     * The HTTP response status code will be 404.
+     * - The `objectOrError` argument defines the JSON response body or the message string.
+     * - The `descriptionOrOptions` argument contains either a short description of the HTTP error or an options object used to provide an underlying error cause.
+     *
+     * By default, the JSON response body contains two properties:
+     * - `statusCode`: this will be the value 404.
+     * - `message`: the string `'Not Found'` by default; override this by supplying
+     * a string in the `objectOrError` parameter.
+     *
+     * If the parameter `objectOrError` is a string, the response body will contain an
+     * additional property, `error`, with a short description of the HTTP error. To override the
+     * entire JSON response body, pass an object instead. Venok will serialize the object
+     * and return it as the JSON response body.
+     *
+     * @param objectOrError string or object describing the error condition.
+     * @param descriptionOrOptions either a short description of the HTTP error or an options object used to provide an underlying error cause
+     */
+    constructor(objectOrError?: string | object | any, descriptionOrOptions?: string | HttpExceptionOptions);
+}

package/errors/not-found.exception.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundException = void 0;
+const enums_1 = require("../enums");
+const http_exception_1 = require("./http.exception");
+/**
+ * Defines an HTTP exception for *Not Found* type errors.
+ *
+ * @publicApi
+ */
+class NotFoundException extends http_exception_1.HttpException {
+    /**
+     * Instantiate a `NotFoundException` Exception.
+     *
+     * @example
+     * `throw new NotFoundException()`
+     *
+     * @usageNotes
+     * The HTTP response status code will be 404.
+     * - The `objectOrError` argument defines the JSON response body or the message string.
+     * - The `descriptionOrOptions` argument contains either a short description of the HTTP error or an options object used to provide an underlying error cause.
+     *
+     * By default, the JSON response body contains two properties:
+     * - `statusCode`: this will be the value 404.
+     * - `message`: the string `'Not Found'` by default; override this by supplying
+     * a string in the `objectOrError` parameter.
+     *
+     * If the parameter `objectOrError` is a string, the response body will contain an
+     * additional property, `error`, with a short description of the HTTP error. To override the
+     * entire JSON response body, pass an object instead. Venok will serialize the object
+     * and return it as the JSON response body.
+     *
+     * @param objectOrError string or object describing the error condition.
+     * @param descriptionOrOptions either a short description of the HTTP error or an options object used to provide an underlying error cause
+     */
+    constructor(objectOrError, descriptionOrOptions = "Not Found") {
+        const { description, httpExceptionOptions } = http_exception_1.HttpException.extractDescriptionAndOptionsFrom(descriptionOrOptions);
+        super(http_exception_1.HttpException.createBody(objectOrError, description, enums_1.HttpStatus.NOT_FOUND), enums_1.HttpStatus.NOT_FOUND, httpExceptionOptions);
+    }
+}
+exports.NotFoundException = NotFoundException;

package/errors/unknown-request-mapping.exception.d.ts

@@ -0,0 +1,5 @@
+import { Type } from "@venok/core";
+import { RuntimeException } from "@venok/core/errors/exceptions";
+export declare class UnknownRequestMappingException extends RuntimeException {
+    constructor(metatype: Type);
+}

package/errors/unknown-request-mapping.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownRequestMappingException = void 0;
+const exceptions_1 = require("../../core/errors/exceptions");
+const messages_1 = require("../exceptions/messages");
+class UnknownRequestMappingException extends exceptions_1.RuntimeException {
+    constructor(metatype) {
+        super((0, messages_1.UNKNOWN_REQUEST_MAPPING)(metatype));
+    }
+}
+exports.UnknownRequestMappingException = UnknownRequestMappingException;

package/exceptions/messages.d.ts

@@ -0,0 +1,4 @@
+import { Type } from "@venok/core";
+export declare const UNKNOWN_REQUEST_MAPPING: (metatype: Type) => string;
+export declare const INVALID_MIDDLEWARE_CONFIGURATION = "An invalid middleware configuration has been passed inside the module 'configure()' method.";
+export declare const INVALID_MIDDLEWARE_MESSAGE: (text: TemplateStringsArray, name: string) => string;

package/exceptions/messages.js

@@ -0,0 +1,13 @@
+"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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,38 @@
+"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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,195 @@
+"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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,52 @@
+"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

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

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

package/factory/method.factory.d.ts

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

package/factory/method.factory.js

@@ -0,0 +1,30 @@
+"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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,39 @@
+"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

@@ -0,0 +1,13 @@
+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;
+}