@venok/http 1.1.0 → 2.0.0

package/middleware/container.d.ts

@@ -1,13 +0,0 @@
-import { InjectionToken, VenokContainer } from "@venok/core";
-import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
-import { MiddlewareConfiguration } from "../interfaces/middleware";
-export declare class MiddlewareContainer {
-    private readonly container;
-    private readonly middleware;
-    private readonly configurationSets;
-    constructor(container: VenokContainer);
-    getMiddlewareCollection(moduleKey: string): Map<InjectionToken, InstanceWrapper>;
-    getConfigurations(): Map<string, Set<MiddlewareConfiguration>>;
-    insertConfig(configList: MiddlewareConfiguration[], moduleKey: string): void;
-    private getTargetConfig;
-}

package/middleware/container.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiddlewareContainer = void 0;
-const wrapper_1 = require("../../core/injector/instance/wrapper");
-const class_scope_helper_1 = require("../../core/injector/helpers/class-scope.helper");
-const is_durable_helper_1 = require("../../core/injector/helpers/is-durable.helper");
-class MiddlewareContainer {
-    constructor(container) {
-        this.container = container;
-        this.middleware = new Map();
-        this.configurationSets = new Map();
-    }
-    getMiddlewareCollection(moduleKey) {
-        if (!this.middleware.has(moduleKey)) {
-            const moduleRef = this.container.getModuleByKey(moduleKey);
-            // Global change
-            this.middleware.set(moduleKey, new Map());
-        }
-        return this.middleware.get(moduleKey);
-    }
-    getConfigurations() {
-        return this.configurationSets;
-    }
-    insertConfig(configList, moduleKey) {
-        const middleware = this.getMiddlewareCollection(moduleKey);
-        const targetConfig = this.getTargetConfig(moduleKey);
-        const configurations = configList || [];
-        const insertMiddleware = (metatype) => {
-            const token = metatype;
-            middleware.set(token, new wrapper_1.InstanceWrapper({
-                scope: (0, class_scope_helper_1.getClassScope)(metatype),
-                durable: (0, is_durable_helper_1.isDurable)(metatype),
-                name: token?.name ?? token,
-                metatype,
-                token,
-            }));
-        };
-        configurations.forEach((config) => {
-            [].concat(config.middleware).map(insertMiddleware);
-            targetConfig.add(config);
-        });
-    }
-    getTargetConfig(moduleName) {
-        if (!this.configurationSets.has(moduleName)) {
-            this.configurationSets.set(moduleName, new Set());
-        }
-        return this.configurationSets.get(moduleName);
-    }
-}
-exports.MiddlewareContainer = MiddlewareContainer;

package/middleware/extractor.d.ts

@@ -1,15 +0,0 @@
-import { RouteInfo } from "../interfaces";
-import { HttpConfig } from "../application/config";
-export declare class RouteInfoPathExtractor {
-    private readonly httpConfig;
-    private routePathFactory;
-    private readonly prefixPath;
-    private readonly excludedGlobalPrefixRoutes;
-    private readonly versioningConfig?;
-    constructor(httpConfig: HttpConfig);
-    extractPathsFrom({ path, method, version }: RouteInfo): string[];
-    extractPathFrom(route: RouteInfo): string;
-    private isAWildcard;
-    private extractNonWildcardPathFrom;
-    private extractVersionPathFrom;
-}

package/middleware/extractor.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteInfoPathExtractor = void 0;
-const factory_1 = require("../factory");
-const helpers_1 = require("../helpers");
-const enums_1 = require("../enums");
-class RouteInfoPathExtractor {
-    constructor(httpConfig) {
-        this.httpConfig = httpConfig;
-        this.routePathFactory = new factory_1.RoutePathFactory(httpConfig);
-        this.prefixPath = (0, helpers_1.stripEndSlash)((0, helpers_1.addLeadingSlash)(this.httpConfig.getGlobalPrefix()));
-        this.excludedGlobalPrefixRoutes = this.httpConfig.getGlobalPrefixOptions().exclude ?? [];
-        this.versioningConfig = this.httpConfig.getVersioning();
-    }
-    extractPathsFrom({ path, method, version }) {
-        const versionPath = this.extractVersionPathFrom(version);
-        if (this.isAWildcard(path)) {
-            return Array.isArray(this.excludedGlobalPrefixRoutes)
-                ? [
-                    this.prefixPath + versionPath + (0, helpers_1.addLeadingSlash)(path),
-                    ...this.excludedGlobalPrefixRoutes.map((route) => versionPath + (0, helpers_1.addLeadingSlash)(route.path)),
-                ]
-                : [this.prefixPath + versionPath + (0, helpers_1.addLeadingSlash)(path)];
-        }
-        return [this.extractNonWildcardPathFrom({ path, method, version })];
-    }
-    extractPathFrom(route) {
-        if (this.isAWildcard(route.path) && !route.version)
-            return (0, helpers_1.addLeadingSlash)(route.path);
-        return this.extractNonWildcardPathFrom(route);
-    }
-    isAWildcard(path) {
-        return ["*", "/*", "/*/", "(.*)", "/(.*)"].includes(path);
-    }
-    extractNonWildcardPathFrom({ path, method, version }) {
-        const versionPath = this.extractVersionPathFrom(version);
-        if (Array.isArray(this.excludedGlobalPrefixRoutes) &&
-            (0, helpers_1.isRouteExcluded)(this.excludedGlobalPrefixRoutes, path, method)) {
-            return versionPath + (0, helpers_1.addLeadingSlash)(path);
-        }
-        return this.prefixPath + versionPath + (0, helpers_1.addLeadingSlash)(path);
-    }
-    extractVersionPathFrom(version) {
-        if (!version || this.versioningConfig?.type !== enums_1.VersioningType.URI)
-            return "";
-        const versionPrefix = this.routePathFactory.getVersionPrefix(this.versioningConfig);
-        return (0, helpers_1.addLeadingSlash)(versionPrefix + version.toString());
-    }
-}
-exports.RouteInfoPathExtractor = RouteInfoPathExtractor;

package/middleware/index.d.ts

@@ -1 +0,0 @@
-export * from './builder';

package/middleware/index.js

@@ -1,17 +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("./builder"), exports);

package/middleware/module.d.ts

@@ -1,33 +0,0 @@
-import { Injector } from "@venok/core/injector/injector";
-import { HttpServer } from "../interfaces";
-import { GraphInspector } from "@venok/core/inspector/graph-inspector";
-import { MiddlewareContainer } from "./container";
-import { ApplicationConfig, VenokContainer } from "@venok/core";
-import { ApplicationContextOptions } from "@venok/core/interfaces/application/context-options.interface";
-import { Module } from "@venok/core/injector/module/module";
-import { MiddlewareConfiguration, RouteInfo } from "../interfaces";
-import { HttpConfig } from "../application/config";
-export declare class MiddlewareModule<TAppOptions extends ApplicationContextOptions = ApplicationContextOptions> {
-    private readonly routerProxy;
-    private readonly exceptionFiltersCache;
-    private readonly logger;
-    private injector;
-    private routerExceptionFilter;
-    private routesMapper;
-    private resolver;
-    private container;
-    private httpAdapter;
-    private graphInspector;
-    private appOptions;
-    private routeInfoPathExtractor;
-    register(middlewareContainer: MiddlewareContainer, container: VenokContainer, applicationConfig: ApplicationConfig, httpConfig: HttpConfig, injector: Injector, httpAdapter: HttpServer, graphInspector: GraphInspector, options: TAppOptions): Promise<void>;
-    resolveMiddleware(middlewareContainer: MiddlewareContainer, modules: Map<string, Module>): Promise<void>;
-    loadConfiguration(middlewareContainer: MiddlewareContainer, moduleRef: Module, moduleKey: string): Promise<void>;
-    registerMiddleware(middlewareContainer: MiddlewareContainer, applicationRef: any): Promise<void>;
-    registerMiddlewareConfig(middlewareContainer: MiddlewareContainer, config: MiddlewareConfiguration, moduleKey: string, applicationRef: any): Promise<void>;
-    registerRouteMiddleware(middlewareContainer: MiddlewareContainer, routeInfo: RouteInfo, config: MiddlewareConfiguration, moduleKey: string, applicationRef: any): Promise<void>;
-    private bindHandler;
-    private createProxy;
-    private registerHandler;
-    private getContextId;
-}

package/middleware/module.js

@@ -1,180 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiddlewareModule = void 0;
-const context_1 = require("../filters/context");
-const logger_service_1 = require("../../core/services/logger.service");
-const routes_mapper_1 = require("./routes-mapper");
-const resolver_1 = require("./resolver");
-const extractor_1 = require("./extractor");
-const builder_1 = require("./builder");
-const module_1 = require("../../core/injector/module/module");
-const shared_helper_1 = require("../../core/helpers/shared.helper");
-const exceptions_1 = require("../../core/errors/exceptions");
-const enums_1 = require("../enums");
-const execution_host_1 = require("../../core/context/execution-host");
-const constants_1 = require("../../core/injector/constants");
-const helpers_1 = require("../helpers");
-const factory_1 = require("../factory");
-const constants_2 = require("../constants");
-const invalid_middleware_exception_1 = require("../errors/invalid-middleware.exception");
-const context_2 = require("../../core/context");
-class MiddlewareModule {
-    constructor() {
-        this.routerProxy = new context_2.VenokProxy();
-        this.exceptionFiltersCache = new WeakMap();
-        this.logger = new logger_service_1.Logger(module_1.Module.name);
-    }
-    async register(middlewareContainer, container, applicationConfig, httpConfig, injector, httpAdapter, graphInspector, options) {
-        this.appOptions = options;
-        const appRef = httpConfig.getHttpAdapterRef();
-        this.routerExceptionFilter = new context_1.RouterExceptionFiltersContext(container, applicationConfig, appRef);
-        this.routesMapper = new routes_mapper_1.RoutesMapper(container, httpConfig);
-        this.resolver = new resolver_1.MiddlewareResolver(middlewareContainer, injector);
-        this.routeInfoPathExtractor = new extractor_1.RouteInfoPathExtractor(httpConfig);
-        this.injector = injector;
-        this.container = container;
-        this.httpAdapter = httpAdapter;
-        this.graphInspector = graphInspector;
-        const modules = container.getModules();
-        await this.resolveMiddleware(middlewareContainer, modules);
-    }
-    async resolveMiddleware(middlewareContainer, modules) {
-        const moduleEntries = [...modules.entries()];
-        const loadMiddlewareConfiguration = async ([moduleName, moduleRef]) => {
-            await this.loadConfiguration(middlewareContainer, moduleRef, moduleName);
-            await this.resolver.resolveInstances(moduleRef, moduleName);
-        };
-        await Promise.all(moduleEntries.map(loadMiddlewareConfiguration));
-    }
-    async loadConfiguration(middlewareContainer, moduleRef, moduleKey) {
-        const { instance } = moduleRef;
-        if (!instance.configure)
-            return;
-        const middlewareBuilder = new builder_1.MiddlewareBuilder(this.routesMapper, this.httpAdapter, this.routeInfoPathExtractor);
-        try {
-            await instance.configure(middlewareBuilder);
-        }
-        catch (err) {
-            if (!this.appOptions.preview)
-                throw err;
-            const warningMessage = `Warning! "${moduleRef.name}" module exposes a "configure" method that throws an exception in the preview mode` +
-                ` (possibly due to missing dependencies). Note: you can ignore this message, just be aware that some of those conditional middlewares will not be reflected in your graph.`;
-            this.logger.warn(warningMessage);
-        }
-        if (!(middlewareBuilder instanceof builder_1.MiddlewareBuilder))
-            return;
-        const config = middlewareBuilder.build();
-        middlewareContainer.insertConfig(config, moduleKey);
-    }
-    async registerMiddleware(middlewareContainer, applicationRef) {
-        const configs = middlewareContainer.getConfigurations();
-        const registerAllConfigs = async (moduleKey, middlewareConfig) => {
-            for (const config of middlewareConfig) {
-                await this.registerMiddlewareConfig(middlewareContainer, config, moduleKey, applicationRef);
-            }
-        };
-        const entriesSortedByDistance = [...configs.entries()].sort(([moduleA], [moduleB]) => {
-            return this.container.getModuleByKey(moduleA).distance - this.container.getModuleByKey(moduleB).distance;
-        });
-        for (const [moduleRef, moduleConfigurations] of entriesSortedByDistance) {
-            await registerAllConfigs(moduleRef, [...moduleConfigurations]);
-        }
-    }
-    async registerMiddlewareConfig(middlewareContainer, config, moduleKey, applicationRef) {
-        const { forRoutes } = config;
-        for (const routeInfo of forRoutes) {
-            await this.registerRouteMiddleware(middlewareContainer, routeInfo, config, moduleKey, applicationRef);
-        }
-    }
-    async registerRouteMiddleware(middlewareContainer, routeInfo, config, moduleKey, applicationRef) {
-        const middlewareCollection = [].concat(config.middleware);
-        const moduleRef = this.container.getModuleByKey(moduleKey);
-        for (const metatype of middlewareCollection) {
-            const collection = middlewareContainer.getMiddlewareCollection(moduleKey);
-            const instanceWrapper = collection.get(metatype);
-            if ((0, shared_helper_1.isUndefined)(instanceWrapper))
-                throw new exceptions_1.RuntimeException();
-            if (instanceWrapper.isTransient)
-                return;
-            this.graphInspector.insertClassNode(moduleRef, instanceWrapper, "middleware");
-            const middlewareDefinition = {
-                type: "middleware",
-                methodName: "use",
-                className: instanceWrapper.name,
-                classNodeId: instanceWrapper.id,
-                metadata: {
-                    key: routeInfo.path,
-                    path: routeInfo.path,
-                    requestMethod: enums_1.RequestMethod[routeInfo.method] ?? "ALL",
-                    version: routeInfo.version,
-                },
-            };
-            this.graphInspector.insertEntrypointDefinition(middlewareDefinition, instanceWrapper.id);
-            await this.bindHandler(instanceWrapper, applicationRef, routeInfo, moduleRef, collection);
-        }
-    }
-    async bindHandler(wrapper, applicationRef, routeInfo, moduleRef, collection) {
-        const { instance, metatype } = wrapper;
-        if ((0, shared_helper_1.isUndefined)(instance?.use))
-            throw new invalid_middleware_exception_1.InvalidMiddlewareException(metatype.name);
-        const isStatic = wrapper.isDependencyTreeStatic();
-        if (isStatic) {
-            const proxy = await this.createProxy(instance);
-            return this.registerHandler(applicationRef, routeInfo, proxy);
-        }
-        const isTreeDurable = wrapper.isDependencyTreeDurable();
-        await this.registerHandler(applicationRef, routeInfo, async (req, res, next) => {
-            try {
-                const contextId = this.getContextId(req, isTreeDurable);
-                const contextInstance = await this.injector.loadPerContext(instance, moduleRef, collection, contextId);
-                const proxy = await this.createProxy(contextInstance, contextId);
-                return proxy(req, res, next);
-            }
-            catch (err) {
-                let exceptionsHandler = this.exceptionFiltersCache.get(instance.use);
-                if (!exceptionsHandler) {
-                    exceptionsHandler = this.routerExceptionFilter.create(instance, instance.use, undefined);
-                    this.exceptionFiltersCache.set(instance.use, exceptionsHandler);
-                }
-                const host = new execution_host_1.ExecutionContextHost([req, res, next]);
-                exceptionsHandler.next(err, host);
-            }
-        });
-    }
-    async createProxy(instance, contextId = constants_1.STATIC_CONTEXT) {
-        const exceptionsHandler = this.routerExceptionFilter.create(instance, instance.use, undefined, contextId);
-        const middleware = instance.use.bind(instance);
-        return this.routerProxy.createProxy(middleware, exceptionsHandler);
-    }
-    async registerHandler(applicationRef, routeInfo, proxy) {
-        const { method } = routeInfo;
-        const paths = this.routeInfoPathExtractor.extractPathsFrom(routeInfo);
-        const isMethodAll = (0, helpers_1.isRequestMethodAll)(method);
-        const requestMethod = enums_1.RequestMethod[method];
-        const router = await applicationRef.createMiddlewareFactory(method);
-        const middlewareFunction = isMethodAll
-            ? proxy
-            : (req, res, next) => {
-                if (applicationRef.getRequestMethod && applicationRef.getRequestMethod(req) === requestMethod) {
-                    return proxy(req, res, next);
-                }
-                return next();
-            };
-        paths.forEach((path) => router(path, middlewareFunction));
-    }
-    getContextId(request, isTreeDurable) {
-        const contextId = factory_1.ContextIdFactory.getByRequest(request);
-        if (!request[constants_2.REQUEST_CONTEXT_ID]) {
-            Object.defineProperty(request, constants_2.REQUEST_CONTEXT_ID, {
-                value: contextId,
-                enumerable: false,
-                writable: false,
-                configurable: false,
-            });
-            const requestProviderValue = isTreeDurable ? contextId.payload : request;
-            this.container.registerRequestProvider(requestProviderValue, contextId);
-        }
-        return contextId;
-    }
-}
-exports.MiddlewareModule = MiddlewareModule;

package/middleware/resolver.d.ts

@@ -1,10 +0,0 @@
-import { MiddlewareContainer } from "./container";
-import { Injector } from "@venok/core/injector/injector";
-import { Module } from "@venok/core/injector/module/module";
-export declare class MiddlewareResolver {
-    private readonly middlewareContainer;
-    private readonly injector;
-    constructor(middlewareContainer: MiddlewareContainer, injector: Injector);
-    resolveInstances(moduleRef: Module, moduleName: string): Promise<void>;
-    private resolveMiddlewareInstance;
-}

package/middleware/resolver.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiddlewareResolver = void 0;
-const shared_helper_1 = require("../../core/helpers/shared.helper");
-const constants_1 = require("../../core/injector/constants");
-class MiddlewareResolver {
-    constructor(middlewareContainer, injector) {
-        this.middlewareContainer = middlewareContainer;
-        this.injector = injector;
-    }
-    async resolveInstances(moduleRef, moduleName) {
-        const middlewareMap = this.middlewareContainer.getMiddlewareCollection(moduleName);
-        const resolveInstance = async (wrapper) => this.resolveMiddlewareInstance(wrapper, middlewareMap, moduleRef);
-        await Promise.all([...middlewareMap.values()].map(resolveInstance));
-    }
-    async resolveMiddlewareInstance(wrapper, middlewareMap, moduleRef) {
-        const { metatype, token } = wrapper;
-        const targetWrapper = middlewareMap.get(token);
-        if (!targetWrapper)
-            return;
-        if (!(0, shared_helper_1.isUndefined)(targetWrapper.instance))
-            return;
-        targetWrapper.instance = Object.create(metatype.prototype);
-        await this.injector.loadInstance(wrapper, middlewareMap, moduleRef, constants_1.STATIC_CONTEXT, wrapper);
-    }
-}
-exports.MiddlewareResolver = MiddlewareResolver;

package/middleware/routes-mapper.d.ts

@@ -1,19 +0,0 @@
-import { Type, VenokContainer } from "@venok/core";
-import { HttpConfig } from "../application/config";
-import { RouteInfo } from "../interfaces";
-export declare class RoutesMapper {
-    private readonly container;
-    private readonly httpConfig;
-    private readonly pathsExplorer;
-    constructor(container: VenokContainer, httpConfig: HttpConfig);
-    mapRouteToRouteInfo(controllerOrRoute: Type | RouteInfo | string): RouteInfo[];
-    private getRouteInfoFromPath;
-    private getRouteInfoFromObject;
-    private getRouteInfoFromController;
-    private isRouteInfo;
-    private normalizeGlobalPath;
-    private getRoutePath;
-    private getHostModuleOfController;
-    private getModulePath;
-    private getVersionMetadata;
-}

package/middleware/routes-mapper.js

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoutesMapper = void 0;
-const path_explorer_1 = require("../explorers/path.explorer");
-const core_1 = require("../../core");
-const interfaces_1 = require("../interfaces");
-const shared_helper_1 = require("../../core/helpers/shared.helper");
-const helpers_1 = require("../helpers");
-const constants_1 = require("../constants");
-const module_1 = require("../router/module");
-const constants_2 = require("../../core/constants");
-class RoutesMapper {
-    constructor(container, httpConfig) {
-        this.container = container;
-        this.httpConfig = httpConfig;
-        this.pathsExplorer = new path_explorer_1.PathsExplorer(new core_1.MetadataScanner());
-    }
-    mapRouteToRouteInfo(controllerOrRoute) {
-        if ((0, shared_helper_1.isString)(controllerOrRoute))
-            return this.getRouteInfoFromPath(controllerOrRoute);
-        const routePathOrPaths = this.getRoutePath(controllerOrRoute);
-        if (this.isRouteInfo(routePathOrPaths, controllerOrRoute))
-            return this.getRouteInfoFromObject(controllerOrRoute);
-        return this.getRouteInfoFromController(controllerOrRoute, routePathOrPaths);
-    }
-    getRouteInfoFromPath(routePath) {
-        const defaultRequestMethod = -1;
-        return [
-            {
-                path: (0, helpers_1.addLeadingSlash)(routePath),
-                method: defaultRequestMethod,
-            },
-        ];
-    }
-    getRouteInfoFromObject(routeInfoObject) {
-        const routeInfo = {
-            path: (0, helpers_1.addLeadingSlash)(routeInfoObject.path),
-            method: routeInfoObject.method,
-        };
-        if (routeInfoObject.version)
-            routeInfo.version = routeInfoObject.version;
-        return [routeInfo];
-    }
-    getRouteInfoFromController(controller, routePath) {
-        const controllerPaths = this.pathsExplorer.scanForPaths(Object.create(controller), controller.prototype);
-        const controllerVersion = this.getVersionMetadata(controller);
-        const versioningConfig = this.httpConfig.getVersioning();
-        const moduleRef = this.getHostModuleOfController(controller);
-        const modulePath = this.getModulePath(moduleRef?.metatype);
-        const concatPaths = (acc, currentValue) => acc.concat(currentValue);
-        const toUndefinedIfNeural = (version) => (version === interfaces_1.VERSION_NEUTRAL ? undefined : version);
-        const toRouteInfo = (item, prefix) => item.path
-            ?.map((p) => {
-            let endpointPath = modulePath ?? "";
-            endpointPath += this.normalizeGlobalPath(prefix) + (0, helpers_1.addLeadingSlash)(p);
-            const routeInfo = {
-                path: endpointPath,
-                method: item.requestMethod,
-            };
-            const version = item.version ?? controllerVersion;
-            if (version && versioningConfig) {
-                if (typeof version !== "string" && Array.isArray(version)) {
-                    return version.map((v) => ({
-                        ...routeInfo,
-                        version: toUndefinedIfNeural(v),
-                    }));
-                }
-                routeInfo.version = toUndefinedIfNeural(version);
-            }
-            return routeInfo;
-        })
-            .flat();
-        const mapped = Array.isArray(routePath) ? routePath : [routePath];
-        return mapped
-            .map((path) => controllerPaths.map((item) => toRouteInfo(item, path)).reduce(concatPaths, []))
-            .reduce(concatPaths, []);
-    }
-    isRouteInfo(path, objectOrClass) {
-        return (0, shared_helper_1.isUndefined)(path);
-    }
-    normalizeGlobalPath(path) {
-        const prefix = (0, helpers_1.addLeadingSlash)(path);
-        return prefix === "/" ? "" : prefix;
-    }
-    getRoutePath(route) {
-        return Reflect.getMetadata(constants_1.PATH_METADATA, route);
-    }
-    getHostModuleOfController(metatype) {
-        if (!metatype)
-            return;
-        const modulesContainer = this.container.getModules();
-        const moduleRefsSet = module_1.targetModulesByContainer.get(modulesContainer);
-        if (!moduleRefsSet)
-            return;
-        const modules = Array.from(modulesContainer.values()).filter((moduleRef) => moduleRefsSet.has(moduleRef));
-        return modules.find(({ injectables }) => injectables.has(metatype));
-    }
-    getModulePath(metatype) {
-        if (!metatype)
-            return;
-        const modulesContainer = this.container.getModules();
-        const modulePath = Reflect.getMetadata(constants_2.MODULE_PATH + modulesContainer.applicationId, metatype);
-        return modulePath ?? Reflect.getMetadata(constants_2.MODULE_PATH, metatype);
-    }
-    getVersionMetadata(metatype) {
-        const versioningConfig = this.httpConfig.getVersioning();
-        if (versioningConfig)
-            return Reflect.getMetadata(constants_1.VERSION_METADATA, metatype) ?? versioningConfig.defaultVersion;
-    }
-}
-exports.RoutesMapper = RoutesMapper;

package/middleware/utils.d.ts

@@ -1,8 +0,0 @@
-import { ExcludeRouteMetadata, HttpServer, RouteInfo } from "../interfaces";
-import { Type } from "@venok/core";
-export declare const mapToExcludeRoute: (routes: (string | RouteInfo)[]) => ExcludeRouteMetadata[];
-export declare const filterMiddleware: <T extends Function | Type<any> = any>(middleware: T[], routes: RouteInfo[], httpAdapter: HttpServer) => Type<any>[];
-export declare const mapToClass: <T extends Function | Type<any>>(middleware: T, excludedRoutes: ExcludeRouteMetadata[], httpAdapter: HttpServer) => Type<any>;
-export declare function isMiddlewareClass(middleware: any): middleware is Type;
-export declare function assignToken(metatype: Type, token?: string): Type;
-export declare function isMiddlewareRouteExcluded(req: Record<string, any>, excludedRoutes: ExcludeRouteMetadata[], httpAdapter: HttpServer): boolean;

package/middleware/utils.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMiddlewareRouteExcluded = exports.assignToken = exports.isMiddlewareClass = exports.mapToClass = exports.filterMiddleware = exports.mapToExcludeRoute = void 0;
-const path_to_regexp_1 = require("path-to-regexp");
-const uid_1 = require("uid");
-const shared_helper_1 = require("../../core/helpers/shared.helper");
-const enums_1 = require("../enums");
-const helpers_1 = require("../helpers");
-const mapToExcludeRoute = (routes) => {
-    return routes.map((route) => {
-        if ((0, shared_helper_1.isString)(route)) {
-            return {
-                path: route,
-                requestMethod: enums_1.RequestMethod.ALL,
-                pathRegex: (0, path_to_regexp_1.pathToRegexp)((0, helpers_1.addLeadingSlash)(route)),
-            };
-        }
-        return {
-            path: route.path,
-            requestMethod: route.method,
-            pathRegex: (0, path_to_regexp_1.pathToRegexp)((0, helpers_1.addLeadingSlash)(route.path)),
-        };
-    });
-};
-exports.mapToExcludeRoute = mapToExcludeRoute;
-const filterMiddleware = (middleware, routes, httpAdapter) => {
-    const excludedRoutes = (0, exports.mapToExcludeRoute)(routes);
-    return middleware.filter(shared_helper_1.isFunction).map((item) => (0, exports.mapToClass)(item, excludedRoutes, httpAdapter));
-};
-exports.filterMiddleware = filterMiddleware;
-const mapToClass = (middleware, excludedRoutes, httpAdapter) => {
-    if (isMiddlewareClass(middleware)) {
-        if (excludedRoutes.length <= 0) {
-            return middleware;
-        }
-        const MiddlewareHost = class extends middleware {
-            use(...params) {
-                const [req, _, next] = params;
-                const isExcluded = isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter);
-                if (isExcluded) {
-                    return next();
-                }
-                return super.use(...params);
-            }
-        };
-        return assignToken(MiddlewareHost, middleware.name);
-    }
-    return assignToken(class {
-        constructor() {
-            this.use = (...params) => {
-                const [req, _, next] = params;
-                const isExcluded = isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter);
-                if (isExcluded) {
-                    return next();
-                }
-                return middleware(...params);
-            };
-        }
-    });
-};
-exports.mapToClass = mapToClass;
-function isMiddlewareClass(middleware) {
-    const middlewareStr = middleware.toString();
-    if (middlewareStr.substring(0, 5) === "class") {
-        return true;
-    }
-    const middlewareArr = middlewareStr.split(" ");
-    return (middlewareArr[0] === "function" && /[A-Z]/.test(middlewareArr[1]?.[0]) && (0, shared_helper_1.isFunction)(middleware.prototype?.use));
-}
-exports.isMiddlewareClass = isMiddlewareClass;
-function assignToken(metatype, token = (0, uid_1.uid)(21)) {
-    Object.defineProperty(metatype, "name", { value: token });
-    return metatype;
-}
-exports.assignToken = assignToken;
-function isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter) {
-    if (excludedRoutes.length <= 0 || !httpAdapter.getRequestUrl || !httpAdapter.getRequestMethod) {
-        return false;
-    }
-    const reqMethod = httpAdapter.getRequestMethod(req);
-    const originalUrl = httpAdapter.getRequestUrl(req);
-    const queryParamsIndex = originalUrl && originalUrl.indexOf("?");
-    const pathname = (0, shared_helper_1.isNumber)(queryParamsIndex) && queryParamsIndex >= 0 ? originalUrl.slice(0, +queryParamsIndex) : originalUrl;
-    return (0, helpers_1.isRouteExcluded)(excludedRoutes, pathname, enums_1.RequestMethod[reqMethod]);
-}
-exports.isMiddlewareRouteExcluded = isMiddlewareRouteExcluded;

package/router/module.d.ts

@@ -1,18 +0,0 @@
-import { DynamicModule, ModulesContainer } from "@venok/core";
-import { Module as ModuleClass } from "@venok/core/injector/module/module";
-import { Routes } from "../interfaces";
-export declare const ROUTES: unique symbol;
-export declare const targetModulesByContainer: WeakMap<ModulesContainer, WeakSet<ModuleClass>>;
-/**
- * @publicApi
- */
-export declare class RouterModule {
-    private readonly modulesContainer;
-    private readonly routes;
-    constructor(modulesContainer: ModulesContainer, routes: Routes);
-    static register(routes: Routes): DynamicModule;
-    private deepCloneRoutes;
-    private initialize;
-    private registerModulePathMetadata;
-    private updateTargetModulesCache;
-}