@venok/http 1.1.0 → 2.0.0

package/dist/http/adapter.js

@@ -0,0 +1,294 @@
+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/http/adapter.ts
+import { isFunction, isNumber, isString, isUndefined, VenokProxy } from "@venok/core";
+import {
+  VENOK_ADAPTER_ADD_MIDDLEWARE,
+  VENOK_ADAPTER_ADD_ROUTE,
+  VENOK_ADAPTER_BUILD,
+  VENOK_ADAPTER_SET_EXCEPTION_FILTER,
+  VENOK_ADAPTER_TRANSFORM_NATIVE_ARGS_TO_CONTEXT
+} from "../symbols.js";
+import { VERSION_NEUTRAL } from "../interfaces/router/version.interface.js";
+import { buildMiddlewareTree, getMiddlewaresForPattern } from "../middleware/tree.js";
+import { mapToExcludeRoute } from "../helpers/middleware.helper.js";
+import { isRouteExcluded } from "../helpers/route.helper.js";
+import { getPathType } from "../helpers/path.helper.js";
+import { HttpVersioningType } from "../enums/version-type.enum.js";
+import { HttpMethod } from "../enums/method.enum.js";
+import { ForbiddenException } from "../exceptions/forbidden.exception.js";
+import { NotFoundException } from "../exceptions/not-found.exception.js";
+import { HttpExceptionFiltersContext } from "../filters/context.js";
+var isStringEmptyOrSpaces = (str) => {
+  return str === null || str.match(/^ *$/) !== null;
+};
+
+class AbstractHttpAdapter {
+  #instance;
+  #filterContext;
+  constructor(instance) {
+    this.#instance = instance;
+  }
+  get instance() {
+    return this.#instance;
+  }
+  routes = new Map;
+  globalVenokMiddlewares = new Set;
+  exactVenokMiddlewares = new Map;
+  patternVenokMiddlewares = new Map;
+  convertMiddlewares(collection) {
+    return [...collection].map(([path, handlers]) => ({ path, handlers }));
+  }
+  applyMiddlewareFilterToHandler(metadata) {
+    if (metadata.excludedPaths) {
+      const excludedPaths = mapToExcludeRoute(metadata.excludedPaths);
+      return async (context) => {
+        const reqMethod = this.getRequestMethod(context);
+        const originalUrl = this.getRequestUrl(context);
+        const queryParamsIndex = originalUrl && originalUrl.indexOf("?");
+        const pathname = isNumber(queryParamsIndex) && queryParamsIndex >= 0 ? originalUrl.slice(0, +queryParamsIndex) : originalUrl;
+        const excluded = isRouteExcluded(excludedPaths, pathname, reqMethod);
+        if (excluded)
+          return;
+        const result = await metadata.use(context);
+        if (result)
+          this.setResponseReply(context, result);
+      };
+    }
+    return async (context) => {
+      const result = await metadata.use(context);
+      if (result)
+        this.setResponseReply(context, result);
+    };
+  }
+  applyHostFilterToHandler(handler, hosts) {
+    return (context) => {
+      const parsedHosts = {};
+      const hostname = this.getRequestHostname(context) || "";
+      for (const exp of hosts) {
+        const match = hostname.match(exp.regexp);
+        if (match) {
+          if (exp.keys.length > 0) {
+            exp.keys.forEach((key, i) => parsedHosts[key.name] = match[i + 1]);
+          } else if (exp.regexp && match.groups) {
+            for (const groupName in match.groups)
+              parsedHosts[groupName] = match.groups[groupName];
+          }
+          this.addAdditionalProp(context, "hosts", parsedHosts);
+          return handler(context);
+        }
+      }
+      throw new ForbiddenException(`Request from this host (${hostname}) is prohibited`);
+    };
+  }
+  applyVersionFilterToHandler(handler, version, options) {
+    return (originalContext) => {
+      if (version === VERSION_NEUTRAL || options.type === HttpVersioningType.URI)
+        return handler(originalContext);
+      if (options.type === HttpVersioningType.CUSTOM) {
+        const handlerForCustomVersioning = (context) => {
+          const extractedVersion = options.extractor(context);
+          if (Array.isArray(version)) {
+            const isVersionIncluded = version.filter((v) => extractedVersion.includes(v));
+            if (Array.isArray(extractedVersion) && isVersionIncluded.length)
+              return handler(context);
+            if (isString(extractedVersion) && version.includes(extractedVersion))
+              return handler(context);
+          } else if (isString(version)) {
+            if (Array.isArray(extractedVersion) && extractedVersion.includes(version))
+              return handler(context);
+            if (isString(extractedVersion) && version === extractedVersion)
+              return handler(context);
+          }
+          return;
+        };
+        return handlerForCustomVersioning(originalContext);
+      }
+      if (options.type === HttpVersioningType.MEDIA_TYPE) {
+        const handlerForMediaTypeVersioning = (context) => {
+          const MEDIA_TYPE_HEADER = "Accept";
+          const headers = this.getRequestHeaders(context);
+          const acceptHeaderValue = headers?.[MEDIA_TYPE_HEADER] || headers?.[MEDIA_TYPE_HEADER.toLowerCase()];
+          const acceptHeaderVersionParameter = acceptHeaderValue ? acceptHeaderValue.split(";")[1] : undefined;
+          if (isUndefined(acceptHeaderVersionParameter)) {
+            if (Array.isArray(version)) {
+              if (version.includes(VERSION_NEUTRAL))
+                return handler(context);
+            }
+          } else {
+            const headerVersion = acceptHeaderVersionParameter.split(options.key)[1];
+            if (Array.isArray(version)) {
+              if (version.includes(headerVersion))
+                return handler(context);
+              else if (isString(version)) {
+                if (version === headerVersion)
+                  return handler(context);
+              }
+            }
+          }
+          return;
+        };
+        return handlerForMediaTypeVersioning(originalContext);
+      }
+      if (options.type === HttpVersioningType.HEADER) {
+        const handlerForHeaderVersioning = (context) => {
+          const headers = this.getRequestHeaders(context);
+          const customHeaderVersionParameter = headers?.[options.header] || headers?.[options.header.toLowerCase()];
+          if (isUndefined(customHeaderVersionParameter) || isStringEmptyOrSpaces(customHeaderVersionParameter || "")) {
+            if (Array.isArray(version) && version.includes(VERSION_NEUTRAL))
+              return handler(context);
+          } else {
+            if (Array.isArray(version)) {
+              if (version.includes(customHeaderVersionParameter?.toString()))
+                return handler(context);
+            } else if (isString(version)) {
+              if (version === customHeaderVersionParameter?.toString())
+                return handler(context);
+            }
+          }
+          return;
+        };
+        return handlerForHeaderVersioning(originalContext);
+      }
+    };
+  }
+  async runChain(context, handlers) {
+    for (const handler of handlers) {
+      if (this.isResponseHandled(context))
+        break;
+      await handler(context);
+    }
+    if (!this.isResponseHandled(context))
+      throw new NotFoundException;
+  }
+  createExceptionHandler(callback) {
+    return this.#filterContext.create({}, callback, undefined);
+  }
+  [VENOK_ADAPTER_SET_EXCEPTION_FILTER](container, config) {
+    this.#filterContext = new HttpExceptionFiltersContext(container, config);
+  }
+  [VENOK_ADAPTER_BUILD]() {
+    const middlewares = [
+      ...this.convertMiddlewares(this.exactVenokMiddlewares),
+      ...this.convertMiddlewares(this.patternVenokMiddlewares)
+    ];
+    const tree = buildMiddlewareTree(middlewares);
+    const result = new Map;
+    const venokProxy = new VenokProxy;
+    for (const [path, metadata] of this.routes) {
+      const mws = getMiddlewaresForPattern(tree, path, metadata.method);
+      const proxiedMiddlewares = mws.map((m) => m.handlers.map((metadata2) => this.applyMiddlewareFilterToHandler(metadata2))).flat(2);
+      const proxiedHandlers = metadata.handlers.map((handlerMetadata) => {
+        let callback = handlerMetadata.handler;
+        if (metadata.useHostFilter) {
+          callback = this.applyHostFilterToHandler(callback, metadata.hosts);
+        }
+        if (metadata.useVersionFilter) {
+          callback = this.applyVersionFilterToHandler(callback, handlerMetadata.version, metadata.versioningOptions);
+        }
+        return callback;
+      });
+      const chain = [...proxiedMiddlewares, ...proxiedHandlers];
+      const handler = this.createExceptionHandler(this.runChain.bind(this));
+      const proxy = venokProxy.createProxy(this.runChain.bind(this), handler);
+      const instanceCallback = async (...args) => {
+        const context = this[VENOK_ADAPTER_TRANSFORM_NATIVE_ARGS_TO_CONTEXT](...args);
+        await proxy(context, chain);
+      };
+      result.set(path, { handler: instanceCallback, method: metadata.method });
+    }
+    return result;
+  }
+  use(pathOrHandler, handler) {
+    if (isString(pathOrHandler)) {
+      if (!isFunction(handler)) {
+        console.error();
+        return this;
+      }
+      if (getPathType(pathOrHandler) === "static")
+        this.addUserMiddleware(this.exactVenokMiddlewares, pathOrHandler, { use: handler, method: HttpMethod.ALL });
+      else
+        this.addUserMiddleware(this.patternVenokMiddlewares, pathOrHandler, { use: handler, method: HttpMethod.ALL });
+      return this;
+    }
+    this.globalVenokMiddlewares.add(pathOrHandler);
+    return this;
+  }
+  get(path, handler) {
+    return this.addUserRoute(path, HttpMethod.GET, handler);
+  }
+  post(path, handler) {
+    return this.addUserRoute(path, HttpMethod.POST, handler);
+  }
+  put(path, handler) {
+    return this.addUserRoute(path, HttpMethod.PUT, handler);
+  }
+  delete(path, handler) {
+    return this.addUserRoute(path, HttpMethod.DELETE, handler);
+  }
+  patch(path, handler) {
+    return this.addUserRoute(path, HttpMethod.PATCH, handler);
+  }
+  all(path, handler) {
+    return this.addUserRoute(path, HttpMethod.ALL, handler);
+  }
+  options(path, handler) {
+    return this.addUserRoute(path, HttpMethod.OPTIONS, handler);
+  }
+  head(path, handler) {
+    return this.addUserRoute(path, HttpMethod.HEAD, handler);
+  }
+  search(path, handler) {
+    return this.addUserRoute(path, HttpMethod.SEARCH, handler);
+  }
+  [VENOK_ADAPTER_ADD_ROUTE](path, info) {
+    if (!this.routes.has(path)) {
+      this.routes.set(path, info);
+      return this;
+    }
+    this.routes.get(path).handlers.push(info.handlers[0]);
+    return this;
+  }
+  [VENOK_ADAPTER_ADD_MIDDLEWARE](path, metadata) {
+    if (getPathType(path) === "static")
+      this.addUserMiddleware(this.exactVenokMiddlewares, path, metadata);
+    else
+      this.addUserMiddleware(this.patternVenokMiddlewares, path, metadata);
+    return this;
+  }
+  addUserMiddleware(collection, path, metadata) {
+    if (collection.has(path))
+      collection.get(path).push(metadata);
+    else
+      collection.set(path, [metadata]);
+  }
+  addUserRoute(path, method, handler) {
+    if (this.routes.has(path))
+      throw new Error;
+    const route = {
+      useVersionFilter: false,
+      useHostFilter: false,
+      method,
+      handlers: [{ handler }]
+    };
+    this.routes.set(path, route);
+    return this;
+  }
+}
+export {
+  AbstractHttpAdapter
+};

package/dist/http/config.js

@@ -0,0 +1,67 @@
+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/http/config.ts
+import { Inject, Injectable } from "@venok/core";
+import { HTTP_APP_OPTIONS } from "../http/configurable-module.js";
+class HttpConfig {
+  options;
+  globalPrefix = "";
+  globalPrefixOptions = {};
+  versioningOptions;
+  adapter;
+  constructor(options) {
+    this.options = options;
+    this.adapter = this.options.adapter;
+  }
+  setHttpAdapter(httpAdapter) {
+    this.adapter = httpAdapter;
+  }
+  getHttpAdapterRef() {
+    return this.adapter;
+  }
+  setGlobalPrefix(prefix) {
+    this.globalPrefix = prefix;
+  }
+  getGlobalPrefix() {
+    return this.globalPrefix;
+  }
+  setGlobalPrefixOptions(options) {
+    this.globalPrefixOptions = options;
+  }
+  getGlobalPrefixOptions() {
+    return this.globalPrefixOptions;
+  }
+  enableVersioning(options) {
+    if (Array.isArray(options.defaultVersion)) {
+      options.defaultVersion = Array.from(new Set(options.defaultVersion));
+    }
+    this.versioningOptions = options;
+  }
+  getVersioning() {
+    return this.versioningOptions;
+  }
+}
+HttpConfig = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(HTTP_APP_OPTIONS)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Required === "undefined" ? Object : Required
+  ])
+], HttpConfig);
+export {
+  HttpConfig
+};

package/dist/http/configurable-module.js

@@ -0,0 +1,26 @@
+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/http/configurable-module.ts
+import { ConfigurableModuleBuilder } from "@venok/integration";
+var {
+  ConfigurableModuleClass: HttpConfigurableModuleClass,
+  MODULE_OPTIONS_TOKEN: HTTP_APP_OPTIONS
+} = new ConfigurableModuleBuilder().build();
+export {
+  HttpConfigurableModuleClass,
+  HTTP_APP_OPTIONS
+};

package/dist/http/context.js

@@ -0,0 +1,117 @@
+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/http/context.ts
+import { ApplicationContext, isEmpty, isString, STATIC_CONTEXT, VenokContextCreator } from "@venok/core";
+import { isObservable, lastValueFrom } from "rxjs";
+import {
+  HEADERS_METADATA,
+  METHOD_METADATA,
+  REDIRECT_METADATA,
+  RESPONSE_PASSTHROUGH_METADATA
+} from "../constants.js";
+import { HttpCode } from "../decorators/http-code.decorator.js";
+import { HttpParamtypes } from "../enums/paramtypes.enum.js";
+import { HttpStatus } from "../enums/status.enum.js";
+import { HttpConfig } from "../http/config.js";
+
+class HttpContextCreator extends VenokContextCreator {
+  _adapter;
+  get adapter() {
+    if (this._adapter)
+      return this._adapter;
+    const context = new ApplicationContext(this.container, this.container.applicationConfig);
+    this._adapter = context.get(HttpConfig).getHttpAdapterRef();
+    return this._adapter;
+  }
+  create(instance, callback, methodName, metadataKey, paramsFactory, contextId = STATIC_CONTEXT, inquirerId, options = {
+    interceptors: true,
+    guards: true,
+    filters: false,
+    callback: undefined
+  }, contextType = "native") {
+    const moduleKey = this.getContextModuleKey(instance.constructor);
+    const { getParamsMetadata } = super.getMetadata(instance, methodName, metadataKey, paramsFactory, contextType);
+    const { fnHandleResponse, httpStatusCode, responseHeaders, hasCustomHeaders } = this.getExternalMetadata(getParamsMetadata, instance, callback, methodName, moduleKey);
+    const doneCallback = async (result2, ctx) => {
+      this.adapter.setResponseStatus(ctx, httpStatusCode);
+      if (hasCustomHeaders) {
+        responseHeaders.forEach(({ name, value }) => this.adapter.setResponseHeader(ctx, name, value));
+      }
+      await fnHandleResponse(result2, ctx);
+    };
+    const result = super.create(instance, callback, methodName, metadataKey, paramsFactory, contextId, inquirerId, { ...options, callback: doneCallback }, contextType);
+    const exceptionFilter = this.filtersContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+    return this.venokProxy.createProxy(result, exceptionFilter);
+  }
+  getExternalMetadata(getParamsMetadata, instance, callback, methodName, moduleKey) {
+    const paramsMetadata = getParamsMetadata(moduleKey);
+    const isResponsePassthrough = this.isResponsePassthrough(instance, methodName, paramsMetadata);
+    const httpRedirectResponse = this.reflectRedirect(callback);
+    const fnHandleResponse = this.createHandleResponseFn(callback, isResponsePassthrough, httpRedirectResponse);
+    const method = this.reflectMethod(callback);
+    const httpCode = this.reflectHttpStatusCode(callback);
+    const httpStatusCode = httpCode ? httpCode : this.adapter.getStatusByMethod(method);
+    const responseHeaders = this.reflectResponseHeaders(callback);
+    const hasCustomHeaders = !isEmpty(responseHeaders);
+    return {
+      fnHandleResponse,
+      httpStatusCode,
+      hasCustomHeaders,
+      responseHeaders
+    };
+  }
+  reflectRedirect(callback) {
+    return Reflect.getMetadata(REDIRECT_METADATA, callback);
+  }
+  reflectMethod(callback) {
+    return Reflect.getMetadata(METHOD_METADATA, callback);
+  }
+  reflectResponseHeaders(callback) {
+    return Reflect.getMetadata(HEADERS_METADATA, callback) || [];
+  }
+  reflectHttpStatusCode(callback) {
+    return this.reflector.get(HttpCode, callback);
+  }
+  createHandleResponseFn(callback, isResponsePassthrough, redirectResponse) {
+    if (redirectResponse && isString(redirectResponse.url)) {
+      return async (result, ctx) => {
+        result = await this.transformToResult(result);
+        const statusCode = result && result.statusCode ? result.statusCode : redirectResponse.statusCode ? redirectResponse.statusCode : HttpStatus.FOUND;
+        const url = result && result.url ? result.url : redirectResponse.url;
+        await this.adapter.setResponseRedirect(ctx, statusCode, url);
+      };
+    }
+    return async (result, ctx) => {
+      result = await this.transformToResult(result);
+      !isResponsePassthrough && await this.adapter.setResponseReply(ctx, result, undefined);
+      return ctx;
+    };
+  }
+  async transformToResult(resultOrDeferred) {
+    if (isObservable(resultOrDeferred))
+      return lastValueFrom(resultOrDeferred);
+    return resultOrDeferred;
+  }
+  isResponsePassthrough(instance, methodName, paramsMetadata) {
+    const hasResponseOrNextDecorator = paramsMetadata.some(({ type }) => type === HttpParamtypes.CONTEXT);
+    const isPassthroughEnabled = Reflect.getMetadata(RESPONSE_PASSTHROUGH_METADATA, instance.constructor, methodName);
+    return hasResponseOrNextDecorator && !isPassthroughEnabled;
+  }
+}
+export {
+  HttpContextCreator
+};

package/dist/http/explorer.js

@@ -0,0 +1,133 @@
+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/http/explorer.ts
+import { Inject, Logger, MetadataScanner, MODULE_PATH } from "@venok/core";
+import { ExplorerService } from "@venok/integration";
+import { pathToRegexp } from "path-to-regexp";
+import { RouteDiscovery } from "../helpers/discovery.helper.js";
+import { HttpVersioningType } from "../enums/version-type.enum.js";
+import { addLeadingSlash } from "../helpers/path.helper.js";
+import { RoutePathFactory } from "../router/path-factory.js";
+import { RouteFinder } from "../router/finder.js";
+import { HttpExceptionFiltersContext } from "../filters/context.js";
+import { HttpContextCreator } from "../http/context.js";
+import { HttpConfig } from "../http/config.js";
+import { CONTROLLER_MAPPING_MESSAGE, ROUTE_MAPPED_MESSAGE, VERSIONED_CONTROLLER_MAPPING_MESSAGE, VERSIONED_ROUTE_MAPPED_MESSAGE } from "../helpers/messages.helper.js";
+class HttpExplorerService extends ExplorerService {
+  paramsFactory;
+  pathFactory;
+  logger = new Logger(HttpExplorerService.name, { timestamp: true });
+  routeFinder = new RouteFinder(new MetadataScanner);
+  onModuleInit() {
+    this.pathFactory = new RoutePathFactory(this.httpConfig);
+    this.paramsFactory = this.httpConfig.getHttpAdapterRef().getParamsFactory();
+  }
+  getSettings() {
+    return {
+      contextType: "http",
+      isRequestScopeSupported: true,
+      exceptionsFilterClass: HttpExceptionFiltersContext,
+      contextCreatorClass: HttpContextCreator,
+      options: { guards: true, interceptors: true, filters: false }
+    };
+  }
+  filterProperties(wrapper, metadataKey) {
+    if (!wrapper.metatype)
+      return;
+    const controllerDiscovery = this.get(metadataKey, wrapper.metatype);
+    if (!controllerDiscovery)
+      return;
+    const info = this.routeFinder.getControllerInfo(controllerDiscovery, this.httpConfig);
+    const name = wrapper.metatype.name;
+    const globalPrefix = addLeadingSlash(this.httpConfig.getGlobalPrefix());
+    const modulePath = this.getModulePathMetadata(wrapper.metatype);
+    controllerDiscovery.setDiscovery({ class: wrapper.instance.constructor });
+    info.prefixes.forEach((controllerPath) => {
+      this.logController(controllerPath, info.version, name, globalPrefix, modulePath);
+      const routes = this.routeFinder.getControllerRoutes(wrapper.instance);
+      routes.forEach((route) => {
+        const callback = this.createCallback(wrapper, route.methodName);
+        const isVersioned = !!((route.version || info.version) && info.versioningOptions);
+        route.paths.map((methodPath) => {
+          const metadata = {
+            modulePath,
+            globalPrefix,
+            methodPath,
+            controllerPath,
+            methodVersion: route.version,
+            controllerVersion: info.version,
+            versioningOptions: info.versioningOptions
+          };
+          this.pathFactory.create(metadata, route.requestMethod).forEach((path) => {
+            let parsedHosts = undefined;
+            if (info.host) {
+              const hosts = Array.isArray(info.host) ? info.host : [info.host];
+              parsedHosts = hosts.map((host) => {
+                const keys = [];
+                const regexp = pathToRegexp(host, keys);
+                return { regexp, keys };
+              });
+            }
+            const routeDiscovery = new RouteDiscovery({
+              path,
+              method: route.requestMethod,
+              useVersionFilter: isVersioned && info.versioningOptions.type !== HttpVersioningType.URI,
+              hosts: parsedHosts,
+              versioningOptions: info.versioningOptions,
+              useHostFilter: !!info.host,
+              handlers: [
+                {
+                  handler: callback,
+                  version: this.pathFactory.getVersion(metadata)
+                }
+              ]
+            });
+            routeDiscovery.setDiscovery({ class: wrapper.instance.constructor, handler: wrapper.instance[route.methodName] });
+            controllerDiscovery.pushItem(routeDiscovery);
+          });
+          this.logRoute(metadata, route.requestMethod, isVersioned);
+        });
+      });
+    });
+    return controllerDiscovery;
+  }
+  getModulePathMetadata(metatype) {
+    const modulesContainer = this.container.getModules();
+    const modulePath = Reflect.getMetadata(MODULE_PATH + modulesContainer.applicationId, metatype);
+    return modulePath ?? Reflect.getMetadata(MODULE_PATH, metatype);
+  }
+  logController(path, version, name, globalPrefix, modulePath) {
+    this.pathFactory.create({ controllerPath: path, globalPrefix, modulePath }).forEach((controllerPath) => {
+      const message = !version ? CONTROLLER_MAPPING_MESSAGE(name, controllerPath) : VERSIONED_CONTROLLER_MAPPING_MESSAGE(name, controllerPath, version);
+      this.logger.log(message);
+    });
+  }
+  logRoute(metadata, method, isVersioned) {
+    const pathsToLog = this.pathFactory.create({ ...metadata, versioningOptions: undefined }, method);
+    pathsToLog.forEach((routePath) => {
+      const message = isVersioned ? VERSIONED_ROUTE_MAPPED_MESSAGE(routePath, method, this.pathFactory.getVersion(metadata)) : ROUTE_MAPPED_MESSAGE(routePath, method);
+      this.logger.log(message);
+    });
+  }
+}
+__legacyDecorateClassTS([
+  Inject(HttpConfig),
+  __legacyMetadataTS("design:type", typeof HttpConfig === "undefined" ? Object : HttpConfig)
+], HttpExplorerService.prototype, "httpConfig", undefined);
+export {
+  HttpExplorerService
+};

package/dist/http/module.js

@@ -0,0 +1,35 @@
+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/http/module.ts
+import { IntegrationModule } from "@venok/integration";
+import { Module } from "@venok/core";
+import { HttpConfigurableModuleClass } from "../http/configurable-module.js";
+import { HttpMiddlewareService } from "../middleware/service.js";
+import { HttpStarterModule } from "../http/starter-module.js";
+import { HttpExplorerService } from "../http/explorer.js";
+import { HttpConfig } from "../http/config.js";
+class HttpModule extends HttpConfigurableModuleClass {
+}
+HttpModule = __legacyDecorateClassTS([
+  Module({
+    imports: [IntegrationModule],
+    providers: [HttpConfig, HttpMiddlewareService, HttpExplorerService, HttpStarterModule]
+  })
+], HttpModule);
+export {
+  HttpModule
+};