@venok/http 1.1.0 → 2.0.0

package/dist/index.js

@@ -0,0 +1,82 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/http/src/index.ts
+import"reflect-metadata";
+
+export * from "./decorators/controller.decorator.js";
+export * from "./decorators/header.decorator.js";
+export * from "./decorators/http-code.decorator.js";
+export * from "./decorators/http-params.decorator.js";
+export * from "./decorators/method.decorator.js";
+export * from "./decorators/redirect.decorator.js";
+export * from "./decorators/version.decorator.js";
+export * from "./enums/method.enum.js";
+export * from "./enums/paramtypes.enum.js";
+export * from "./enums/status.enum.js";
+export * from "./enums/version-type.enum.js";
+export * from "./exceptions/bad-gateway.exception.js";
+export * from "./exceptions/bad-request.exception.js";
+export * from "./exceptions/conflict.exception.js";
+export * from "./exceptions/expectation-failed.exception.js";
+export * from "./exceptions/failed-dependency.exception.js";
+export * from "./exceptions/forbidden.exception.js";
+export * from "./exceptions/gateway-timeout.exception.js";
+export * from "./exceptions/gone.exception.js";
+export * from "./exceptions/http-version-not-supported.exception.js";
+export * from "./exceptions/http.exception.js";
+export * from "./exceptions/im-a-teapot.exception.js";
+export * from "./exceptions/internal-server-error.exception.js";
+export * from "./exceptions/length-required.exception.js";
+export * from "./exceptions/method-not-allowed.exception.js";
+export * from "./exceptions/misdirected.exception.js";
+export * from "./exceptions/not-acceptable.exception.js";
+export * from "./exceptions/not-found.exception.js";
+export * from "./exceptions/not-implemented.exception.js";
+export * from "./exceptions/payload-too-large.exception.js";
+export * from "./exceptions/payment-required.exception.js";
+export * from "./exceptions/precondition-failed.exception.js";
+export * from "./exceptions/precondition-required.exception.js";
+export * from "./exceptions/proxy-authentication-required.exception.js";
+export * from "./exceptions/request-timeout.exception.js";
+export * from "./exceptions/requested-range-not-satisfiable.exception.js";
+export * from "./exceptions/service-unavailable.exception.js";
+export * from "./exceptions/too-many-requests.exception.js";
+export * from "./exceptions/unauthorized.exception.js";
+export * from "./exceptions/unprocessable-entity.exception.js";
+export * from "./exceptions/unsupported-media-type.exception.js";
+export * from "./exceptions/uri-too-long.exception.js";
+export * from "./filters/filter.js";
+export * from "./helpers/middleware.helper.js";
+export * from "./helpers/path.helper.js";
+export * from "./helpers/route.helper.js";
+export * from "./http/adapter.js";
+export * from "./http/config.js";
+export * from "./http/module.js";
+export * from "./interfaces/index.js";
+export * from "./middleware/module.js";
+export * from "./router/module.js";
+export * from "./constants.js";
+import {
+  VENOK_APPLY_ROUTES_TO_INSTANCE,
+  VENOK_ADAPTER_RESPONSE,
+  VENOK_ADAPTER_TRANSFORM_NATIVE_ARGS_TO_CONTEXT
+} from "./symbols.js";
+export {
+  VENOK_APPLY_ROUTES_TO_INSTANCE,
+  VENOK_ADAPTER_TRANSFORM_NATIVE_ARGS_TO_CONTEXT,
+  VENOK_ADAPTER_RESPONSE
+};

package/dist/interfaces/index.js

@@ -0,0 +1,7 @@
+// packages/http/src/interfaces/index.ts
+export * from "../interfaces/middleware/index.js";
+export * from "../interfaces/router/index.js";
+export * from "./adapter.interface.js";
+export * from "./exception.interface.js";
+export * from "./options.interface.js";
+export * from "./prefix.interface.js";

package/dist/interfaces/middleware/index.js

@@ -0,0 +1,3 @@
+// packages/http/src/interfaces/middleware/index.ts
+export * from "./config-proxy.interface.js";
+export * from "./consumer.interface.js";

package/dist/interfaces/router/index.js

@@ -0,0 +1,7 @@
+// packages/http/src/interfaces/router/index.ts
+export * from "./definition.interface.js";
+export * from "./exclude-route.interface.js";
+export * from "./info.interface.js";
+export * from "./path-metadata.interface.js";
+export * from "./tree.interface.js";
+export * from "./version.interface.js";

package/dist/interfaces/router/version.interface.js

@@ -0,0 +1,21 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/http/src/interfaces/router/version.interface.ts
+var VERSION_NEUTRAL = Symbol("VERSION_NEUTRAL");
+export {
+  VERSION_NEUTRAL
+};

package/dist/middleware/builder.js

@@ -0,0 +1,96 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/http/src/middleware/builder.ts
+import { flatten } from "@venok/core";
+import { filterMiddleware } from "../helpers/middleware.helper.js";
+import { stripEndSlash } from "../helpers/path.helper.js";
+
+class MiddlewareBuilder {
+  middlewareRoutesMapper;
+  httpAdapter;
+  middlewareCollection = new Set;
+  constructor(middlewareRoutesMapper, httpAdapter) {
+    this.middlewareRoutesMapper = middlewareRoutesMapper;
+    this.httpAdapter = httpAdapter;
+  }
+  apply(...middleware) {
+    return new MiddlewareBuilder.ConfigProxy(this, flatten(middleware));
+  }
+  build() {
+    return [...this.middlewareCollection];
+  }
+  getHttpAdapter() {
+    return this.httpAdapter;
+  }
+  static ConfigProxy = class {
+    builder;
+    middleware;
+    excludedRoutes = [];
+    constructor(builder, middleware) {
+      this.builder = builder;
+      this.middleware = middleware;
+    }
+    getExcludedRoutes() {
+      return this.excludedRoutes;
+    }
+    exclude(...routes) {
+      this.excludedRoutes = [
+        ...this.excludedRoutes,
+        ...this.getRoutesFlatList(routes)
+      ];
+      return this;
+    }
+    to(...routes) {
+      const { middlewareCollection } = this.builder;
+      const flattedRoutes = this.getRoutesFlatList(routes);
+      const forRoutes = this.removeOverlappedRoutes(flattedRoutes);
+      const configuration = {
+        middleware: filterMiddleware(this.middleware),
+        to: forRoutes,
+        exclude: this.excludedRoutes
+      };
+      middlewareCollection.add(configuration);
+      return this.builder;
+    }
+    getRoutesFlatList(routes) {
+      const { middlewareRoutesMapper } = this.builder;
+      return flatten(routes.map((route) => middlewareRoutesMapper.mapRouteToRouteInfo(route)));
+    }
+    removeOverlappedRoutes(routes) {
+      const regexMatchParams = /(:[^\/]*)/g;
+      const wildcard = "([^/]*)";
+      const routesWithRegex = routes.filter((route) => route.path.includes(":")).map((route) => ({
+        method: route.method,
+        path: route.path,
+        regex: new RegExp("^(" + route.path.replace(regexMatchParams, wildcard) + ")$", "g")
+      }));
+      return routes.filter((route) => {
+        const isOverlapped = (item) => {
+          if (route.method !== item.method)
+            return false;
+          const normalizedRoutePath = stripEndSlash(route.path);
+          return normalizedRoutePath !== item.path && item.regex.test(normalizedRoutePath);
+        };
+        const routeMatch = routesWithRegex.find(isOverlapped);
+        return routeMatch === undefined;
+      });
+    }
+  };
+}
+export {
+  MiddlewareBuilder
+};

package/dist/middleware/module.js

@@ -0,0 +1,22 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/http/src/middleware/module.ts
+class HttpMiddlewareModule {
+}
+export {
+  HttpMiddlewareModule
+};

package/dist/middleware/routes-mapper.js

@@ -0,0 +1,107 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/http/src/middleware/routes-mapper.ts
+import { isString, MetadataScanner, MODULE_PATH, Reflector } from "@venok/core";
+import { RoutePathFactory } from "../router/path-factory.js";
+import { RouteFinder } from "../router/finder.js";
+import { addLeadingSlash } from "../helpers/path.helper.js";
+import { Controller } from "../decorators/controller.decorator.js";
+import { targetModulesByContainer } from "../router/module.js";
+import { HttpMethod } from "../enums/method.enum.js";
+
+class MiddlewareRoutesMapper {
+  container;
+  httpConfig;
+  routeFinder;
+  routePathFactory;
+  constructor(container, httpConfig) {
+    this.container = container;
+    this.httpConfig = httpConfig;
+    this.routeFinder = new RouteFinder(new MetadataScanner);
+    this.routePathFactory = new RoutePathFactory(this.httpConfig);
+  }
+  mapRouteToRouteInfo(controllerOrRoute) {
+    if (isString(controllerOrRoute))
+      return this.getRouteInfoFromPath(controllerOrRoute);
+    return this.isRouteInfo(controllerOrRoute) ? this.getRouteInfoFromObject(controllerOrRoute) : this.getRouteInfoFromController(controllerOrRoute);
+  }
+  isRouteInfo(controllerOrRoute) {
+    return "path" in controllerOrRoute;
+  }
+  getRouteInfoFromPath(routePath) {
+    const globalPrefix = addLeadingSlash(this.httpConfig.getGlobalPrefix());
+    const path = this.routePathFactory.create({ methodPath: routePath, globalPrefix })[0];
+    return [{ path, method: HttpMethod.ALL }];
+  }
+  getRouteInfoFromObject(routeInfoObject) {
+    const globalPrefix = addLeadingSlash(this.httpConfig.getGlobalPrefix());
+    const paths = this.routePathFactory.create({
+      methodPath: routeInfoObject.path,
+      globalPrefix,
+      versioningOptions: this.httpConfig.getVersioning(),
+      methodVersion: routeInfoObject.version
+    });
+    return paths.map((path) => ({ path, method: routeInfoObject.method }));
+  }
+  getRouteInfoFromController(controller) {
+    const discovery = Reflector.reflector.get(Controller, controller);
+    const info = this.routeFinder.getControllerInfo(discovery, this.httpConfig);
+    const globalPrefix = addLeadingSlash(this.httpConfig.getGlobalPrefix());
+    const moduleRef = this.getHostModuleOfController(controller);
+    const modulePath = this.getModulePath(moduleRef?.metatype);
+    const routes = this.routeFinder.getControllerRoutes(Object.create(controller), controller.prototype);
+    const output = [];
+    info.prefixes.forEach((controllerPath) => {
+      routes.forEach((route) => {
+        route.paths.forEach((methodPath) => {
+          const metadata = {
+            modulePath,
+            globalPrefix,
+            methodPath,
+            controllerPath,
+            methodVersion: route.version,
+            controllerVersion: info.version,
+            versioningOptions: info.versioningOptions
+          };
+          const routeInfos = this.routePathFactory.create(metadata, route.requestMethod).map((endpoint) => ({ path: endpoint, method: route.requestMethod }));
+          output.push(...routeInfos);
+        });
+      });
+    });
+    return output;
+  }
+  getHostModuleOfController(metatype) {
+    if (!metatype)
+      return;
+    const modulesContainer = this.container.getModules();
+    const moduleRefsSet = 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(MODULE_PATH + modulesContainer.applicationId, metatype);
+    return modulePath ?? Reflect.getMetadata(MODULE_PATH, metatype);
+  }
+}
+export {
+  MiddlewareRoutesMapper
+};

package/dist/middleware/service.js

@@ -0,0 +1,48 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/http/src/middleware/service.ts
+import { MiddlewareService } from "@venok/integration";
+import { Inject, Injectable } from "@venok/core";
+import { HttpConfig } from "../http/config.js";
+import { MiddlewareRoutesMapper } from "../middleware/routes-mapper.js";
+import { MiddlewareBuilder } from "../middleware/builder.js";
+import { HttpExceptionFiltersContext } from "../filters/context.js";
+import { VENOK_ADAPTER_ADD_MIDDLEWARE } from "../symbols.js";
+class HttpMiddlewareService extends MiddlewareService {
+  routesMapper;
+  onModuleInit() {
+    this.exceptionsFilter = new HttpExceptionFiltersContext(this.container, this.container.applicationConfig);
+    this.routesMapper = new MiddlewareRoutesMapper(this.container, this.httpConfig);
+  }
+  getMiddlewareBuilder() {
+    return new MiddlewareBuilder(this.routesMapper, this.httpConfig.getHttpAdapterRef());
+  }
+  registerHandler(info, proxy, config) {
+    const adapter = this.httpConfig.getHttpAdapterRef();
+    adapter[VENOK_ADAPTER_ADD_MIDDLEWARE](info.path, { use: proxy, method: info.method, excludedPaths: config.exclude });
+  }
+}
+__legacyDecorateClassTS([
+  Inject(HttpConfig),
+  __legacyMetadataTS("design:type", typeof HttpConfig === "undefined" ? Object : HttpConfig)
+], HttpMiddlewareService.prototype, "httpConfig", undefined);
+HttpMiddlewareService = __legacyDecorateClassTS([
+  Injectable()
+], HttpMiddlewareService);
+export {
+  HttpMiddlewareService
+};

package/dist/middleware/tree.js

@@ -0,0 +1,91 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/http/src/middleware/tree.ts
+import { HttpMethod } from "../enums/method.enum.js";
+var buildMiddlewareTree = (middlewares) => {
+  const root = { segment: "/", children: new Map, middlewares: [] };
+  for (const mw of middlewares) {
+    const parts = mw.path.split("/").filter(Boolean);
+    let current = root;
+    for (const part of parts) {
+      if (!current.children.has(part))
+        current.children.set(part, { segment: part, children: new Map, middlewares: [] });
+      current = current.children.get(part);
+    }
+    current.middlewares.push(mw);
+  }
+  return root;
+};
+var filterMiddlewaresByMethod = (middlewares, method) => {
+  return middlewares.map((middleware) => {
+    const handlers = middleware.handlers.filter((metadata) => metadata.method === method || metadata.method === HttpMethod.ALL);
+    if (handlers.length === 0)
+      return null;
+    return { path: middleware.path, handlers };
+  }).filter(Boolean);
+};
+var getMiddlewaresForPattern = (tree, pathPattern, method) => {
+  const parts = pathPattern.split("/").filter(Boolean);
+  const chain = [];
+  const visited = new Set;
+  function addMiddleware(node) {
+    if (!node.middlewares.length)
+      return;
+    const filtered = filterMiddlewaresByMethod(node.middlewares, method);
+    for (const middleware of filtered) {
+      if (!visited.has(middleware.path)) {
+        chain.push(middleware);
+        visited.add(middleware.path);
+      }
+    }
+  }
+  function traversePath(node, pathIndex) {
+    if (!node)
+      return;
+    addMiddleware(node);
+    if (pathIndex >= parts.length)
+      return;
+    const part = parts[pathIndex];
+    const wildcard = node.children.get("*");
+    if (wildcard && part !== "*") {
+      addMiddleware(wildcard);
+      traversePath(wildcard, pathIndex + 1);
+    }
+    const paramNode = Array.from(node.children.values()).find((c) => c.segment.startsWith(":"));
+    if (paramNode && !part.startsWith(":")) {
+      addMiddleware(paramNode);
+      traversePath(paramNode, pathIndex + 1);
+    }
+    const literalNode = node.children.get(part);
+    if (literalNode) {
+      traversePath(literalNode, pathIndex + 1);
+      return;
+    }
+    if (part.startsWith(":") && paramNode) {
+      traversePath(paramNode, pathIndex + 1);
+    } else if (part === "*" && wildcard) {
+      traversePath(wildcard, pathIndex + 1);
+    }
+  }
+  traversePath(tree, 0);
+  return chain;
+};
+export {
+  getMiddlewaresForPattern,
+  filterMiddlewaresByMethod,
+  buildMiddlewareTree
+};

package/dist/router/finder.js

@@ -0,0 +1,64 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/http/src/router/finder.ts
+import { isString, isUndefined } from "@venok/core";
+import { METHOD_METADATA, PATH_METADATA, VERSION_METADATA } from "../constants.js";
+import { addLeadingSlash } from "../helpers/path.helper.js";
+
+class RouteFinder {
+  metadataScanner;
+  constructor(metadataScanner) {
+    this.metadataScanner = metadataScanner;
+  }
+  getControllerInfo(discovery, httpConfig) {
+    const version = discovery.getVersion() ?? httpConfig.getVersioning()?.defaultVersion;
+    const host = discovery.getHost();
+    const prefixes = this.extractControllerPrefixes(discovery.getPrefixes());
+    const versioningOptions = httpConfig.getVersioning();
+    return { version, host, prefixes, versioningOptions };
+  }
+  extractControllerPrefixes(prefixes) {
+    if (isUndefined(prefixes))
+      return [];
+    if (Array.isArray(prefixes))
+      return prefixes.map((prefix) => addLeadingSlash(prefix));
+    return [addLeadingSlash(prefixes)];
+  }
+  getControllerRoutes(instance, prototype) {
+    const instancePrototype = isUndefined(prototype) ? Object.getPrototypeOf(instance) : prototype;
+    return this.metadataScanner.getAllMethodNames(instancePrototype).reduce((acc, method) => {
+      const route = this.exploreMethod(instance, instancePrototype, method);
+      if (route)
+        acc.push(route);
+      return acc;
+    }, []);
+  }
+  exploreMethod(instance, prototype, methodName) {
+    const targetCallback = instance[methodName];
+    const prototypeCallback = prototype[methodName];
+    const routePath = Reflect.getMetadata(PATH_METADATA, prototypeCallback);
+    if (isUndefined(routePath))
+      return null;
+    const requestMethod = Reflect.getMetadata(METHOD_METADATA, prototypeCallback);
+    const version = Reflect.getMetadata(VERSION_METADATA, prototypeCallback);
+    const paths = isString(routePath) ? [addLeadingSlash(routePath)] : routePath.map((p) => addLeadingSlash(p));
+    return { paths, requestMethod, targetCallback, methodName, version };
+  }
+}
+export {
+  RouteFinder
+};