jimpex 7.0.1 → 8.0.0

package/dist/controllers/utils/gateway.js

@@ -0,0 +1,425 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var gateway_exports = {};
+__export(gateway_exports, {
+  GatewayController: () => GatewayController,
+  gatewayController: () => gatewayController
+});
+module.exports = __toCommonJS(gateway_exports);
+var import_deep_assign = require("@homer0/deep-assign");
+var import_object_utils = require("@homer0/object-utils");
+var import_utils = require("../../utils");
+class GatewayController {
+  constructor({
+    inject,
+    route,
+    gatewayConfig,
+    ...options
+  }) {
+    __publicField(this, "http");
+    __publicField(this, "_getHelperService");
+    __publicField(this, "_gatewayConfig");
+    __publicField(this, "_route");
+    __publicField(this, "_routeExpression");
+    __publicField(this, "_options");
+    __publicField(this, "_endpoints");
+    __publicField(this, "_apiConfigUrl");
+    __publicField(this, "_apiConfigEndpoints");
+    __publicField(this, "_routes");
+    this.http = inject.http;
+    this._getHelperService = inject.getHelperService || (() => void 0);
+    this._route = (0, import_utils.removeSlashes)(route);
+    this._options = this._formatOptions(
+      (0, import_deep_assign.deepAssignWithOverwrite)(
+        {
+          root: "",
+          apiConfigSetting: "api",
+          headers: {
+            useXForwardedFor: true,
+            copyCustomHeaders: true,
+            copy: ["authorization", "content-type", "referer", "user-agent"],
+            remove: ["server", "x-powered-by", "content-encoding"]
+          }
+        },
+        options
+      )
+    );
+    this._gatewayConfig = {
+      ...gatewayConfig,
+      url: (0, import_utils.removeSlashes)(gatewayConfig.url, false, true)
+    };
+    this._routeExpression = (0, import_utils.createRouteExpression)(
+      this._options.root ? `${this._route}/${this._options.root}` : this._route,
+      true,
+      true
+    );
+    this._endpoints = this._formatEndpoints();
+    this._routes = this._createRoutes();
+    const { url, endpoints } = this._createAPIConfig();
+    this._apiConfigUrl = url;
+    this._apiConfigEndpoints = endpoints;
+  }
+  getAPIConfig({
+    setting,
+    placeholders = {}
+  } = {}) {
+    const useSetting = setting || this._options.apiConfigSetting;
+    let url;
+    const placeholdersEntries = Object.entries(placeholders);
+    if (placeholdersEntries.length) {
+      url = placeholdersEntries.reduce(
+        (acc, [key, value]) => acc.replace(`:${key}`, value),
+        this._apiConfigUrl
+      );
+    } else {
+      url = this._apiConfigUrl;
+    }
+    return {
+      url,
+      endpoints: {
+        [useSetting]: this._apiConfigEndpoints
+      }
+    };
+  }
+  addRoutes(router, middlewares = []) {
+    this._routes.forEach((route) => {
+      route.methods.forEach((info) => {
+        this._addRoute({
+          router,
+          method: info.method,
+          route: route.route,
+          gatewayMiddleware: this._createGatewayMiddleware(info.endpoint),
+          middlewares
+        });
+      });
+    });
+    return router;
+  }
+  get options() {
+    return { ...this._options };
+  }
+  get gatewayConfig() {
+    return { ...this._gatewayConfig };
+  }
+  _createGatewayMiddleware(endpoint) {
+    return async (req, res, next) => {
+      const {
+        _options: { headers: headersOptions },
+        _gatewayConfig: { url: gatewayUrl },
+        _routeExpression: routeExpression
+      } = this;
+      const reqPath = req.originalUrl.replace(routeExpression, "");
+      let headers = {};
+      headersOptions.copy.forEach((name) => {
+        if (req.headers[name]) {
+          headers[name] = req.headers[name];
+        }
+      });
+      if (headersOptions.copyCustomHeaders) {
+        headers = (0, import_deep_assign.deepAssignWithOverwrite)(
+          headers,
+          this.http.getCustomHeadersFromRequest(req)
+        );
+      }
+      if (headersOptions.useXForwardedFor) {
+        const ip = this.http.getIPFromRequest(req);
+        if (ip) {
+          headers["x-forwarded-for"] = ip;
+        }
+      }
+      const method = req.method.toUpperCase();
+      let body;
+      if (method !== "GET" && typeof req.body === "object") {
+        body = JSON.stringify(req.body);
+        if (!headers["content-type"]) {
+          headers["content-type"] = "application/json";
+        }
+      }
+      const helper = this._getHelperService() || {};
+      const helperBasePayload = {
+        endpoint,
+        req,
+        res,
+        next,
+        helper
+      };
+      try {
+        const request = await this._reduceEndpointRequest({
+          endpointReq: {
+            url: `${gatewayUrl}/${reqPath}`,
+            options: {
+              method,
+              headers,
+              body
+            }
+          },
+          ...helperBasePayload
+        });
+        const responseRaw = await this.http.fetch(request.url, request.options);
+        const response = await this._reduceEndpointResponse({
+          endpointRes: responseRaw,
+          ...helperBasePayload
+        });
+        const shouldStream = await this._shouldStreamEndpointResponse({
+          endpointRes: responseRaw,
+          ...helperBasePayload
+        });
+        if (shouldStream) {
+          res.status(response.status);
+          response.headers.forEach((value, name) => {
+            if (!headersOptions.remove.includes(name)) {
+              res.setHeader(name, value);
+            }
+          });
+          response.body.pipe(res).on("error", (error) => {
+            next(error);
+          });
+        } else {
+          await this._handleEndpointResponse({
+            endpointRes: response,
+            ...helperBasePayload
+          });
+        }
+      } catch (error) {
+        this._handleEndpointError({
+          error,
+          ...helperBasePayload
+        });
+      }
+    };
+  }
+  _addRoute({
+    router,
+    method,
+    route,
+    gatewayMiddleware,
+    middlewares
+  }) {
+    router[method](route, [...middlewares, gatewayMiddleware]);
+  }
+  _formatEndpoints() {
+    return (0, import_object_utils.flat)({
+      target: this._gatewayConfig.gateway,
+      shouldFlatten: (_, value) => {
+        const useValue = value;
+        return typeof useValue.path === "undefined";
+      }
+    });
+  }
+  _createRoutes() {
+    const routes = {};
+    Object.keys(this._endpoints).forEach((name) => {
+      const endpoint = this._endpoints[name];
+      let endpointPath;
+      let endpointMethod;
+      if (typeof endpoint === "string") {
+        endpointPath = endpoint;
+        endpointMethod = "all";
+      } else {
+        endpointPath = endpoint.path;
+        endpointMethod = endpoint.method ? this._validateHTTPMethod(endpoint.method) : "all";
+      }
+      endpointPath = (0, import_utils.removeSlashes)(endpointPath);
+      if (!routes[endpointPath]) {
+        routes[endpointPath] = {
+          path: endpointPath,
+          methods: {}
+        };
+      }
+      if (routes[endpointPath].methods[endpointMethod]) {
+        const repeatedEndpoint = routes[endpointPath].methods[endpointMethod];
+        throw new Error(
+          `You can't have two gateway endpoints to the same path and with the same HTTP method: '${repeatedEndpoint}' and '${name}'`
+        );
+      }
+      routes[endpointPath].methods[endpointMethod] = name;
+    });
+    const routePrefixes = this._options.root ? `/${this._options.root}/` : "/";
+    return Object.keys(routes).map((endpointPath) => {
+      const info = routes[endpointPath];
+      return {
+        path: info.path,
+        route: `${routePrefixes}${info.path}`,
+        methods: Object.keys(info.methods).map((methodNameRaw) => {
+          const methodName = methodNameRaw;
+          const endpointName = info.methods[methodName];
+          const endpointDefinition = this._endpoints[endpointName];
+          return {
+            method: methodName,
+            endpoint: {
+              name: endpointName,
+              definition: endpointDefinition
+            }
+          };
+        })
+      };
+    });
+  }
+  _reduceEndpointRequest({
+    helper,
+    ...options
+  }) {
+    if (helper.reduceEndpointRequest) {
+      return helper.reduceEndpointRequest(options);
+    }
+    return Promise.resolve(options.endpointReq);
+  }
+  _reduceEndpointResponse({
+    helper,
+    ...options
+  }) {
+    if (helper.reduceEndpointResponse) {
+      return helper.reduceEndpointResponse(options);
+    }
+    return Promise.resolve(options.endpointRes);
+  }
+  _shouldStreamEndpointResponse({
+    helper,
+    ...options
+  }) {
+    if (helper.shouldStreamEndpointResponse) {
+      return helper.shouldStreamEndpointResponse(options);
+    }
+    return Promise.resolve(true);
+  }
+  _handleEndpointResponse({
+    helper,
+    ...options
+  }) {
+    if (!helper.handleEndpointResponse) {
+      throw new Error("You must implement handleEndpointResponse");
+    }
+    return helper.handleEndpointResponse(options);
+  }
+  _handleEndpointError({
+    helper,
+    ...options
+  }) {
+    if (helper.handleEndpointError) {
+      return helper.handleEndpointError(options);
+    }
+    return options.next(options.error);
+  }
+  _formatOptions(options) {
+    if (options.root) {
+      const root = (0, import_utils.removeSlashes)(options.root).trim();
+      return { ...options, root };
+    }
+    return options;
+  }
+  _validateHTTPMethod(method) {
+    const newMethod = method.toLowerCase();
+    return [
+      "get",
+      "head",
+      "post",
+      "patch",
+      "put",
+      "delete",
+      "connect",
+      "options",
+      "trace"
+    ].includes(newMethod) ? newMethod : "all";
+  }
+  _createAPIConfig() {
+    let endpoints;
+    const { root } = this._options;
+    if (root) {
+      endpoints = Object.keys(this._endpoints).reduce((acc, name) => {
+        const endpoint = this._endpoints[name];
+        let newEndpoint;
+        if (typeof endpoint === "string") {
+          newEndpoint = (0, import_utils.removeSlashes)(endpoint);
+          newEndpoint = `${root}/${newEndpoint}`;
+        } else {
+          const endpointPath = (0, import_utils.removeSlashes)(endpoint.path);
+          newEndpoint = {
+            ...endpoint,
+            path: `${root}/${endpointPath}`
+          };
+        }
+        acc[name] = newEndpoint;
+        return acc;
+      }, {});
+    } else {
+      endpoints = this._endpoints;
+    }
+    return {
+      url: `/${this._route}`,
+      endpoints: (0, import_object_utils.unflat)({ target: endpoints })
+    };
+  }
+}
+const gatewayController = (0, import_utils.controllerProviderCreator)(
+  (options = {}) => (app, route) => {
+    const defaultServiceName = "apiGateway";
+    let defaultHelperServiceName = "apiGatewayHelper";
+    let defaultConfigSetting = "api";
+    let { serviceName = defaultServiceName } = options;
+    if (serviceName !== defaultServiceName) {
+      defaultConfigSetting = serviceName;
+      if (!serviceName.match(/gateway$/i)) {
+        serviceName = `${serviceName}Gateway`;
+      }
+      defaultHelperServiceName = `${serviceName}Helper`;
+    }
+    app.set(serviceName, () => {
+      const {
+        helperServiceName = defaultHelperServiceName,
+        gatewaySettingName = defaultConfigSetting,
+        gatewayClass: GatewayClass = GatewayController
+      } = options;
+      const gtConfig = app.getConfig(gatewaySettingName);
+      return new GatewayClass({
+        ...options,
+        apiConfigSetting: gatewaySettingName,
+        gatewayConfig: gtConfig,
+        route,
+        inject: {
+          http: app.get("http"),
+          getHelperService: () => app.try(helperServiceName)
+        }
+      });
+    });
+    return (0, import_utils.controller)(() => {
+      const ctrl = app.get(serviceName);
+      let useMiddlewares;
+      if (options.getMiddlewares) {
+        useMiddlewares = options.getMiddlewares(app).map((middleware) => {
+          if ("middleware" in middleware) {
+            return middleware.connect(app);
+          }
+          return middleware;
+        }).filter(import_utils.notUndefined);
+      }
+      return ctrl.addRoutes(app.get("router"), useMiddlewares);
+    });
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GatewayController,
+  gatewayController
+});
+//# sourceMappingURL=gateway.js.map

package/dist/controllers/utils/gateway.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/controllers/utils/gateway.ts"],"sourcesContent":["import { deepAssignWithOverwrite } from '@homer0/deep-assign';\nimport { flat, unflat } from '@homer0/object-utils';\nimport type { APIClientOptions } from '@homer0/api-utils';\nimport {\n  controllerProviderCreator,\n  controller,\n  createRouteExpression,\n  removeSlashes,\n  notUndefined,\n  type MiddlewareLike,\n} from '../../utils';\nimport type { HTTP, HTTPFetchOptions } from '../../services';\nimport type { Jimpex } from '../../app';\nimport {\n  RouterMethod,\n  DeepPartial,\n  Request,\n  Response,\n  NextFunction,\n  HTTPResponse,\n  Router,\n  ExpressMiddleware,\n  AsyncExpressMiddleware,\n} from '../../types';\n/**\n * The extended definition for endpoints.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayConfigEndpointProps = {\n  /**\n   * The path to the endpoint relative to the entry point. It can include placeholders for\n   * parameters like `/:parameter/`.\n   */\n  path: string;\n  /**\n   * The router (HTTP) method for the endpoint.\n   *\n   * @default 'all'\n   */\n  method?: RouterMethod;\n};\n/**\n * The definition of an endpoint: it can be just the path, relative to the entry point, or\n * an object in which you can also specify things like the method.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayConfigEndpointDefinition = string | GatewayConfigEndpointProps;\n/**\n * The dictionary of endpoints the controller uses. The reason for this type is that this\n * could be a flat dictionary, or a nested one.\n *\n * @example\n *\n * <caption>A flat dictionary</caption>\n *\n * {\n *   random: '/random',\n *   users: '/users',\n *   userById: {\n *     path: '/users/:id',\n *     method: 'get',\n *   },\n * }\n *\n * @example\n *\n * <caption>A nested dictionary</caption>\n *\n * {\n *   random: '/random',\n *   users: {\n *     list: '/users',\n *     byId: {\n *       path: '/users/:id',\n *       method: 'get',\n *     },\n *   },\n * }\n *\n * @group Controllers/Gateway\n */\nexport type GatewayConfigEndpoints = {\n  [key: string]: GatewayConfigEndpointDefinition | GatewayConfigEndpoints;\n};\n/**\n * The configuration for the gateway the controller uses.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayConfig = {\n  /**\n   * The entry point to the API the controller will make the requests to.\n   */\n  url: string;\n  /**\n   * The dictionary of enpoints the gateway will make available.\n   */\n  gateway: GatewayConfigEndpoints;\n};\n/**\n * The options for how the gateway will handle the headers from the requests and the\n * responses.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerHeaderOptions = {\n  /**\n   * Whether or not to include the header with the request's IP address.\n   *\n   * @default true\n   */\n  useXForwardedFor: boolean;\n  /**\n   * Whether or not to copy all custom headers from the request. By custom header, it\n   * means all the headers which names start with `x-`.\n   *\n   * @default true\n   */\n  copyCustomHeaders: boolean;\n  /**\n   * A list of \"known\" headers the gateway will try to copy from the incoming request.\n   *\n   * @default ['authorization','content-type', 'referer', 'user-agent']\n   */\n  copy: string[];\n  /**\n   * A list of \"known\" headers the gateway will try to remove the response.\n   *\n   * @default ['server', 'x-powered-by']\n   */\n  remove: string[];\n};\n/**\n * The extra options for the gateway controller. They are \"extra\" because they are mostly\n * helpers for when used with an API client, or for optional features.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerExtraOptions = {\n  /**\n   * This is really a helper for when the gateway is used with an API client. The idea is\n   * that, by default, the routes are mounted on the controller route, but with this\n   * option, you can specify another sub path. For example: The controller is mounted on\n   * `/routes`, and if you set `root` to `gateway`, all the routes will be on\n   * `/routes/gateway`.\n   *\n   * This become important (and useful) when you get the API client configuration (with\n   * `getAPIConfig`): The `url` will be the controller route, but all the endpoints will\n   * be modified and prefixed with the `root`, that way, you can have multiple gateways in\n   * the same \"base route\".\n   *\n   * It can also includes placeholders for parameters like `/:parameter/`, that will be\n   * replaced with the `placeholders` option when `getAPIConfig` gets called.\n   *\n   * @default ''\n   */\n  root: string;\n  /**\n   * This is another option for when the gateway is used with an API client. When calling\n   * `getAPIConfig`, all the endpoints will be wrapped inside an object named after this\n   * option. For example: `{ url: '...', endpoints: { api: { ... } } }`.\n   *\n   * @default 'api'\n   */\n  apiConfigSetting: string;\n  /**\n   * The options for how the gateway will handle the headers from the requests and the\n   * responses.\n   */\n  headers: GatewayControllerHeaderOptions;\n};\n/**\n * The required options for the gateway controller.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerOptions = {\n  /**\n   * The configuration for the API the gateway will make the requests to.\n   */\n  gatewayConfig: GatewayConfig;\n  /**\n   * The route where the controller is mounted.\n   */\n  route: string;\n} & DeepPartial<GatewayControllerExtraOptions>;\n/**\n * The information for a request the controller will make.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerRequest = {\n  /**\n   * The URL for the request.\n   */\n  url: string;\n  /**\n   * The options for the fetch client that will make the requests.\n   */\n  options: HTTPFetchOptions;\n};\n/**\n * The information for an endpoint the gateway is calling.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerEndpointInfo = {\n  /**\n   * The name of the endpoint in the configuration.\n   */\n  name: string;\n  /**\n   * The properties (path and method) of the endpoint.\n   */\n  definition: GatewayConfigEndpointDefinition;\n};\n/**\n * These are the base options sent to all the helper service functions.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayHelperServiceBaseFnOptions = {\n  /**\n   * The information of the endpoint the gateway is calling.\n   */\n  endpoint: GatewayControllerEndpointInfo;\n  /**\n   * The request recived by the application.\n   */\n  req: Request;\n  /**\n   * The response object created by the application.\n   */\n  res: Response;\n  /**\n   * The function to call the next middleware in the chain.\n   */\n  next: NextFunction;\n};\n/**\n * The information sent to the helper service in order to modify, or not, a request before\n * it is sent.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayHelperServiceRequestReducerOptions =\n  GatewayHelperServiceBaseFnOptions & {\n    /**\n     * The options the controller created for the fetch client.\n     */\n    endpointReq: GatewayControllerRequest;\n  };\n/**\n * A function that can be used to modify the information of an endpoint before making a\n * request.\n *\n * @param options  The information of the request.\n * @group Controllers/Gateway\n */\nexport type GatewayHelperServiceRequestReducer = (\n  options: GatewayHelperServiceRequestReducerOptions,\n) => Promise<GatewayControllerRequest>;\n/**\n * The information sent to the helper service in order to modify a response before\n * processing it, decide if it should be streamed or not, and even handle it.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayHelperServiceResponseReducerOptions =\n  GatewayHelperServiceBaseFnOptions & {\n    /**\n     * The response from the endpoint request.\n     */\n    endpointRes: HTTPResponse;\n  };\n/**\n * A function that can be used to modify the response of an endpoint before the controller\n * processes it.\n *\n * @param options  The information of the response.\n * @group Controllers/Gateway\n */\nexport type GatewayHelperServiceResponseReducer = (\n  options: GatewayHelperServiceResponseReducerOptions,\n) => Promise<HTTPResponse>;\n/**\n * A function that can be used to tell the controller to stream the response of an\n * endpoint or not.\n * If it returns `false`, the function to handle responses should be defined, otherwise,\n * an error will be generated.\n *\n * @param options  The information of the response.\n * @group Controllers/Gateway\n */\nexport type GatewayHelperServiceStreamVerification = (\n  options: GatewayHelperServiceResponseReducerOptions,\n) => Promise<boolean>;\n/**\n * A function to handle the response of an endpoint. This is called when the helper\n * service tells the controller that the endpoint shouldn't be streamed, so this method\n * should handle the response.\n *\n * @param options  The information of the response.\n * @group Controllers/Gateway\n */\nexport type GatewayHelperServiceResponseHandler = (\n  options: GatewayHelperServiceResponseReducerOptions,\n) => Promise<void>;\n/**\n * The information sent to the helper service in order to handle a failed request for an\n * endpoint.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayHelperServiceErrorHandlerOptions =\n  GatewayHelperServiceBaseFnOptions & {\n    /**\n     * The error generated during the request.\n     */\n    error: Error;\n  };\n/**\n * A function to handle the error of an endpoint request.\n *\n * @param options  The information of the error.\n * @group Controllers/Gateway\n */\nexport type GatewayHelperServiceErrorHandler = (\n  options: GatewayHelperServiceErrorHandlerOptions,\n) => void;\n/**\n * The interface of a helper service that can intercept/modify the requests and responses\n * the gateway makes.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayHelperService = Partial<{\n  /**\n   * A function that is called before an endpoint request is made.\n   */\n  reduceEndpointRequest: GatewayHelperServiceRequestReducer;\n  /**\n   * A function that is called with the response of an endpoint request.\n   */\n  reduceEndpointResponse: GatewayHelperServiceResponseReducer;\n  /**\n   * A function called in order to validate if an endpoint response should be streamed or\n   * not. If the function returns `false`, `handleEndpointResponse` will be called.\n   */\n  shouldStreamEndpointResponse: GatewayHelperServiceStreamVerification;\n  /**\n   * A function called when `shouldStreamEndpointResponse` returns `false`. The function\n   * should handle the response for the application.\n   */\n  handleEndpointResponse: GatewayHelperServiceResponseHandler;\n  /**\n   * A function called when an error is generated during an endpoint request/processing.\n   */\n  handleEndpointError: GatewayHelperServiceErrorHandler;\n}>;\n/**\n * Utility type for the options object sent to the \"proxy methods\" the controller has for\n * the helper service.\n *\n * @template T  The type of the options for a specific helper service function.\n * @access protected\n * @group Controllers/Gateway\n */\nexport type GatewayControllerHelperOptions<T> = T & {\n  /**\n   * The reference for the helper service.\n   */\n  helper: GatewayHelperService;\n};\n/**\n * The information for a single HTTP method an endpoint can handle.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerRouteMethod = {\n  /**\n   * The method for the route.\n   */\n  method: RouterMethod;\n  /**\n   * The information of the endpoint.\n   */\n  endpoint: GatewayControllerEndpointInfo;\n};\n/**\n * The information for all the HTTP methods that can be handled for an endpoint.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerRoute = {\n  /**\n   * The path to the endpoint, relative to the entry point.\n   */\n  path: string;\n  /**\n   * The path for the route in the controller. This is different from `path` as it's possible for\n   * the gateway to be implemented using the `root` option.\n   */\n  route: string;\n  /**\n   * A list with all the methods the controller uses on the route.\n   */\n  methods: GatewayControllerRouteMethod[];\n};\n/**\n * The API client configuration the gateway can generate for its endpoints.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerAPIConfig = {\n  /**\n   * The base URL for the API.\n   */\n  url: string;\n  /**\n   * The dictionary of endpoints the controller handles.\n   */\n  endpoints: APIClientOptions['endpoints'];\n};\n/**\n * The options sent to {@link GatewayController.getAPIConfig}.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerAPIConfigOptions = {\n  /**\n   * This can be used to overwrite the gateway's `apiConfigSetting` option, and set a new\n   * setting as a wrapper for the endpoints.\n   */\n  setting?: string;\n  /**\n   * A dictionary of values for possible placeholders that were sent using the `root`\n   * option.\n   */\n  placeholders?: Record<string, string>;\n};\n/**\n * The options to construct a {@link GatewayController}.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerConstructorOptions = GatewayControllerOptions & {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    http: HTTP;\n    /**\n     * A function to get a possible helper service. This is injected as a \"getter\" to not\n     * interrupt the DIC \"lifecycle\": controllers are initialized right when the app\n     * starts, and injecting a reference would force the service to be initialized too,\n     * even if a request is not being made.\n     */\n    getHelperService?: () => GatewayHelperService | undefined;\n  };\n};\n/**\n * The options for {@link GatewayController._addRoute}.\n *\n * @access protected\n * @group Controllers/Gateway\n */\nexport type AddGatewayRouteOptions = {\n  /**\n   * The reference for the router in which the middlewares will be added.\n   */\n  router: Router;\n  /**\n   * The router method in which the middlewares will be added.\n   */\n  method: RouterMethod;\n  /**\n   * The route in which the middlewares will be added.\n   */\n  route: string;\n  /**\n   * The middleware created by {@link GatewayController}, that makes the request.\n   */\n  gatewayMiddleware: AsyncExpressMiddleware;\n  /**\n   * A list of extra middlewares to prepend to the gateway middleware.\n   */\n  middlewares: ExpressMiddleware[];\n};\n/**\n * A utility controller that generates routes that act as a gateway for a specific API.\n *\n * @group Controller Classes\n * @group Controllers/Gateway\n * @prettierignore\n */\nexport class GatewayController {\n  /**\n   * The service that makes HTTP requests.\n   */\n  protected readonly http: HTTP;\n  /**\n   * A function to get a possible helper service. This is injected as a \"getter\" to not\n   * interrupt the DIC \"lifecycle\": controllers are initialized right when the app\n   * starts, and injecting a reference would force the service to be initialized too,\n   * even if a request is not being made.\n   */\n  protected readonly _getHelperService: () => GatewayHelperService | undefined;\n  /**\n   * The information, url and endpoints, for the gateway the controller will make requests to.\n   */\n  protected readonly _gatewayConfig: GatewayConfig;\n  /**\n   * The route in which the controller is mounted.\n   */\n  protected readonly _route: string;\n  /**\n   * A regular expression that will be used to remove the controller route from a\n   * request path. This will allow the main middleware to extract the path to where the\n   * request should be made.\n   */\n  protected readonly _routeExpression: RegExp;\n  /**\n   * The controller customization options.\n   */\n  protected readonly _options: GatewayControllerExtraOptions;\n  /**\n   * A flat dictionary with the endpoints information.\n   */\n  protected readonly _endpoints: Record<string, GatewayConfigEndpointDefinition>;\n  /**\n   * The entry URL for the API client configuration the controller can generate.\n   */\n  protected readonly _apiConfigUrl: string;\n  /**\n   * The generated endpoints for the API client configuration the controller can generate.\n   */\n  protected readonly _apiConfigEndpoints: APIClientOptions['endpoints'];\n  /**\n   * The list of routes the controller can handle.\n   */\n  protected readonly _routes: GatewayControllerRoute[];\n  /**\n   * @param options  The options to construct the controller.\n   */\n  constructor({\n    inject,\n    route,\n    gatewayConfig,\n    ...options\n  }: GatewayControllerConstructorOptions) {\n    this.http = inject.http;\n    this._getHelperService = inject.getHelperService || (() => undefined);\n    this._route = removeSlashes(route);\n    this._options = this._formatOptions(\n      deepAssignWithOverwrite(\n        {\n          root: '',\n          apiConfigSetting: 'api',\n          headers: {\n            useXForwardedFor: true,\n            copyCustomHeaders: true,\n            copy: ['authorization', 'content-type', 'referer', 'user-agent'],\n            remove: ['server', 'x-powered-by', 'content-encoding'],\n          },\n        },\n        options,\n      ),\n    );\n    this._gatewayConfig = {\n      ...gatewayConfig,\n      url: removeSlashes(gatewayConfig.url, false, true),\n    };\n    this._routeExpression = createRouteExpression(\n      this._options.root ? `${this._route}/${this._options.root}` : this._route,\n      true,\n      true,\n    );\n    this._endpoints = this._formatEndpoints();\n    this._routes = this._createRoutes();\n    const { url, endpoints } = this._createAPIConfig();\n    this._apiConfigUrl = url;\n    this._apiConfigEndpoints = endpoints;\n  }\n  /**\n   * Generates an API client configuration based on the controller routes.\n   *\n   * @param options  The options to customize the generated configuration.\n   */\n  getAPIConfig({\n    setting,\n    placeholders = {},\n  }: GatewayControllerAPIConfigOptions = {}): Readonly<GatewayControllerAPIConfig> {\n    const useSetting = setting || this._options.apiConfigSetting;\n    let url: string;\n    const placeholdersEntries = Object.entries(placeholders);\n    if (placeholdersEntries.length) {\n      url = placeholdersEntries.reduce<string>(\n        (acc, [key, value]) => acc.replace(`:${key}`, value),\n        this._apiConfigUrl,\n      );\n    } else {\n      url = this._apiConfigUrl;\n    }\n\n    return {\n      url,\n      endpoints: {\n        [useSetting]: this._apiConfigEndpoints,\n      },\n    };\n  }\n  /**\n   * Mounts the middlewares in the router in order to make the requests.\n   *\n   * @param router       A reference to the application router.\n   * @param middlewares  A list of extra middlewares to execute before the gateway\n   *                     middleware.\n   */\n  addRoutes(router: Router, middlewares: ExpressMiddleware[] = []): Router {\n    this._routes.forEach((route) => {\n      route.methods.forEach((info) => {\n        this._addRoute({\n          router,\n          method: info.method,\n          route: route.route,\n          gatewayMiddleware: this._createGatewayMiddleware(info.endpoint),\n          middlewares,\n        });\n      });\n    });\n\n    return router;\n  }\n  /**\n   * The customization options.\n   */\n  get options(): Readonly<GatewayControllerExtraOptions> {\n    return { ...this._options };\n  }\n  /**\n   * The configuration for the gateway the controller will make requests to.\n   */\n  get gatewayConfig(): Readonly<GatewayConfig> {\n    return { ...this._gatewayConfig };\n  }\n  /**\n   * Generates a middleware that will make the request to an endpoint and stream the\n   * response.\n   *\n   * @param endpoint  The information of the endpoint the middleware will handle.\n   */\n  protected _createGatewayMiddleware(\n    endpoint: GatewayControllerEndpointInfo,\n  ): AsyncExpressMiddleware {\n    return async (req, res, next) => {\n      const {\n        _options: { headers: headersOptions },\n        _gatewayConfig: { url: gatewayUrl },\n        _routeExpression: routeExpression,\n      } = this;\n      // Remove the controller route from the requested URL.\n      const reqPath = req.originalUrl.replace(routeExpression, '');\n      // Process the headers for the request.\n      let headers: Record<string, string> = {};\n      // - Copy the headers from the incoming request.\n      headersOptions.copy.forEach((name) => {\n        if (req.headers[name]) {\n          headers[name] = req.headers[name] as string;\n        }\n      });\n      // - Copy the custom headers.\n      if (headersOptions.copyCustomHeaders) {\n        headers = deepAssignWithOverwrite<Record<string, string>>(\n          headers,\n          this.http.getCustomHeadersFromRequest(req),\n        );\n      }\n      // - Include the IP on the X-Forwarded-For header, if enabled.\n      if (headersOptions.useXForwardedFor) {\n        const ip = this.http.getIPFromRequest(req);\n        if (ip) {\n          headers['x-forwarded-for'] = ip;\n        }\n      }\n\n      const method = req.method.toUpperCase();\n      // If the request has a body and the method is not `GET`, stringify it.\n      let body: string | undefined;\n      if (method !== 'GET' && typeof req.body === 'object') {\n        body = JSON.stringify(req.body);\n        // If there's no `content-type`, let's assume it's JSON.\n        if (!headers['content-type']) {\n          headers['content-type'] = 'application/json';\n        }\n      }\n\n      /**\n       * Get the helper service, if there's one, and define the base options for its\n       * methods.\n       */\n      const helper = this._getHelperService() || {};\n      const helperBasePayload = {\n        endpoint,\n        req,\n        res,\n        next,\n        helper,\n      };\n\n      try {\n        // Reduce the request information before using it.\n        const request = await this._reduceEndpointRequest({\n          endpointReq: {\n            url: `${gatewayUrl}/${reqPath}`,\n            options: {\n              method,\n              headers,\n              body,\n            },\n          },\n          ...helperBasePayload,\n        });\n        // Make the actual request.\n        const responseRaw = await this.http.fetch(request.url, request.options);\n        // Reduce the response information before using it.\n        const response = await this._reduceEndpointResponse({\n          endpointRes: responseRaw,\n          ...helperBasePayload,\n        });\n        // Validate if the response should be streamed.\n        const shouldStream = await this._shouldStreamEndpointResponse({\n          endpointRes: responseRaw,\n          ...helperBasePayload,\n        });\n\n        if (shouldStream) {\n          /**\n           * If the response should be streamed, set the status, remove unwanted headers,\n           * and pipe it to the application response object.\n           */\n          res.status(response.status);\n          response.headers.forEach((value, name) => {\n            if (!headersOptions.remove.includes(name)) {\n              res.setHeader(name, value);\n            }\n          });\n\n          response.body.pipe(res).on('error', (error) => {\n            next(error);\n          });\n        } else {\n          /**\n           * If the response should not be streamed, send it to the helper method to\n           * handle it.\n           */\n          await this._handleEndpointResponse({\n            endpointRes: response,\n            ...helperBasePayload,\n          });\n        }\n      } catch (error) {\n        // Something failed, so let's pass the error to the helper service.\n        this._handleEndpointError({\n          error: error as Error,\n          ...helperBasePayload,\n        });\n      }\n    };\n  }\n  /**\n   * Mounts the middleware(s) for an endpoint in the router.\n   *\n   * @param options  The information of the endpoint and how it needs to be added.\n   */\n  protected _addRoute({\n    router,\n    method,\n    route,\n    gatewayMiddleware,\n    middlewares,\n  }: AddGatewayRouteOptions): void {\n    router[method](route, [...middlewares, gatewayMiddleware]);\n  }\n  /**\n   * Formats the endpoints for the gateway into a flat dictionary without nesting.\n   */\n  protected _formatEndpoints(): Record<string, GatewayConfigEndpointDefinition> {\n    return flat({\n      target: this._gatewayConfig.gateway,\n      shouldFlatten: (_, value) => {\n        const useValue = value as { path?: string };\n        return typeof useValue.path === 'undefined';\n      },\n    });\n  }\n  /**\n   * Based on the information from the endpoints, this method will create the routes the\n   * controller will later add on a router.\n   *\n   * @throws If there's more than one endpoint using the same path with the same HTTP\n   *         method.\n   */\n  protected _createRoutes(): GatewayControllerRoute[] {\n    const routes: Record<\n      string,\n      {\n        path: string;\n        methods: Partial<Record<RouterMethod, string>>;\n      }\n    > = {};\n    Object.keys(this._endpoints).forEach((name) => {\n      const endpoint = this._endpoints[name]!;\n      let endpointPath: string;\n      let endpointMethod: RouterMethod;\n      if (typeof endpoint === 'string') {\n        endpointPath = endpoint;\n        endpointMethod = 'all';\n      } else {\n        endpointPath = endpoint.path;\n        endpointMethod = endpoint.method\n          ? this._validateHTTPMethod(endpoint.method)\n          : 'all';\n      }\n\n      endpointPath = removeSlashes(endpointPath);\n      if (!routes[endpointPath]) {\n        routes[endpointPath] = {\n          path: endpointPath,\n          methods: {},\n        };\n      }\n\n      if (routes[endpointPath]!.methods[endpointMethod]) {\n        const repeatedEndpoint = routes[endpointPath]!.methods[endpointMethod];\n        throw new Error(\n          \"You can't have two gateway endpoints to the same path and with the same \" +\n            `HTTP method: '${repeatedEndpoint}' and '${name}'`,\n        );\n      }\n\n      routes[endpointPath]!.methods[endpointMethod] = name;\n    });\n\n    const routePrefixes = this._options.root ? `/${this._options.root}/` : '/';\n    return Object.keys(routes).map((endpointPath) => {\n      const info = routes[endpointPath]!;\n      return {\n        path: info.path,\n        route: `${routePrefixes}${info.path}`,\n        methods: Object.keys(info.methods).map((methodNameRaw) => {\n          const methodName = methodNameRaw as RouterMethod;\n          const endpointName = info.methods[methodName]!;\n          const endpointDefinition = this._endpoints[endpointName]!;\n          return {\n            method: methodName,\n            endpoint: {\n              name: endpointName,\n              definition: endpointDefinition,\n            },\n          };\n        }),\n      };\n    });\n  }\n  /**\n   * This is a \"proxy method\" to call the helper service's function that can modify an\n   * endpoint request before it gets made.\n   *\n   * The reason this is a \"proxy method\" is in case the controller gets subclassed and\n   * \"used itself as a helper\" instead of relying on a difference one.\n   *\n   * If the helper doesn't implement `reduceEndpointRequest`, it will just return\n   * information for the request.\n   *\n   * @param options  The information of the request and the reference to the helper.\n   */\n  protected _reduceEndpointRequest({\n    helper,\n    ...options\n  }: GatewayControllerHelperOptions<GatewayHelperServiceRequestReducerOptions>): Promise<GatewayControllerRequest> {\n    if (helper.reduceEndpointRequest) {\n      return helper.reduceEndpointRequest(options);\n    }\n\n    return Promise.resolve(options.endpointReq);\n  }\n  /**\n   * This is a \"proxy method\" to call the helper service's function that can modify an\n   * endpoint response before it gets processed.\n   *\n   * The reason this is a \"proxy method\" is in case the controller gets subclassed and\n   * \"used itself as a helper\" instead of relying on a difference one.\n   *\n   * If the helper doesn't implement `reduceEndpointResponse`, it will just return\n   * information for the response.\n   *\n   * @param options  The information of the response and the reference to the helper.\n   */\n  protected _reduceEndpointResponse({\n    helper,\n    ...options\n  }: GatewayControllerHelperOptions<GatewayHelperServiceResponseReducerOptions>): Promise<HTTPResponse> {\n    if (helper.reduceEndpointResponse) {\n      return helper.reduceEndpointResponse(options);\n    }\n\n    return Promise.resolve(options.endpointRes);\n  }\n  /**\n   * This is a \"proxy method\" to call the helper service's function that can decide if an\n   * endpoint response should be streamed or not.\n   *\n   * The reason this is a \"proxy method\" is in case the controller gets subclassed and\n   * \"used itself as a helper\" instead of relying on a difference one.\n   *\n   * If the helper doesn't implement `shouldStreamEndpointResponse`, it will just return\n   * `true`.\n   *\n   * @param options  The information of the response and the reference to the helper.\n   */\n  protected _shouldStreamEndpointResponse({\n    helper,\n    ...options\n  }: GatewayControllerHelperOptions<GatewayHelperServiceResponseReducerOptions>): Promise<boolean> {\n    if (helper.shouldStreamEndpointResponse) {\n      return helper.shouldStreamEndpointResponse(options);\n    }\n\n    return Promise.resolve(true);\n  }\n  /**\n   * This is a \"proxy method\" to call the helper service's function that handles a\n   * response in case it already said that a response shouldn't be streamed.\n   *\n   * The reason this is a \"proxy method\" is in case the controller gets subclassed and\n   * \"used itself as a helper\" instead of relying on a difference one.\n   *\n   * If the helper doesn't implement `shouldStreamEndpointResponse`, it will throw an\n   * error.\n   *\n   * @param options  The information of the response and the reference to the helper.\n   * @throws If the helper doesn't implement `handleEndpointResponse`.\n   */\n  protected _handleEndpointResponse({\n    helper,\n    ...options\n  }: GatewayControllerHelperOptions<GatewayHelperServiceResponseReducerOptions>): Promise<void> {\n    if (!helper.handleEndpointResponse) {\n      throw new Error('You must implement handleEndpointResponse');\n    }\n\n    return helper.handleEndpointResponse(options);\n  }\n  /**\n   * This is a \"proxy method\" to call the helper service's function that handles an error\n   * on an endpoint request.\n   *\n   * The reason this is a \"proxy method\" is in case the controller gets subclassed and\n   * \"used itself as a helper\" instead of relying on a difference one.\n   *\n   * If the helper doesn't implement `handleEndpointError`, it will just send the error to\n   * the next middleware/error handler.\n   *\n   * @param options  The information of the response and the reference to the helper.\n   */\n  protected _handleEndpointError({\n    helper,\n    ...options\n  }: GatewayControllerHelperOptions<GatewayHelperServiceErrorHandlerOptions>): void {\n    if (helper.handleEndpointError) {\n      return helper.handleEndpointError(options);\n    }\n\n    return options.next(options.error);\n  }\n  /**\n   * Validates and formats the customization options sent to the controller.\n   *\n   * @param options  The options sent to the constructor.\n   */\n  protected _formatOptions(\n    options: GatewayControllerExtraOptions,\n  ): GatewayControllerExtraOptions {\n    if (options.root) {\n      const root = removeSlashes(options.root).trim();\n      return { ...options, root };\n    }\n\n    return options;\n  }\n  /**\n   * Validates a router/HTTP method that the controller intends to use for an endpoint. If\n   * it's not valid, it will return `all`.\n   *\n   * @param method  The HTTP method for the endpoint.\n   */\n  protected _validateHTTPMethod(method: string): RouterMethod {\n    const newMethod = method.toLowerCase();\n    return [\n      'get',\n      'head',\n      'post',\n      'patch',\n      'put',\n      'delete',\n      'connect',\n      'options',\n      'trace',\n    ].includes(newMethod)\n      ? (newMethod as RouterMethod)\n      : 'all';\n  }\n  /**\n   * Creates the API client configuration based on the controller routes.\n   */\n  protected _createAPIConfig(): GatewayControllerAPIConfig {\n    let endpoints: APIClientOptions['endpoints'];\n    const { root } = this._options;\n    if (root) {\n      endpoints = Object.keys(this._endpoints).reduce<\n        Record<string, GatewayConfigEndpointDefinition>\n      >((acc, name) => {\n        const endpoint = this._endpoints[name]!;\n        let newEndpoint;\n        if (typeof endpoint === 'string') {\n          newEndpoint = removeSlashes(endpoint);\n          newEndpoint = `${root}/${newEndpoint}`;\n        } else {\n          const endpointPath = removeSlashes(endpoint.path);\n          newEndpoint = {\n            ...endpoint,\n            path: `${root}/${endpointPath}`,\n          };\n        }\n\n        acc[name] = newEndpoint;\n        return acc;\n      }, {});\n    } else {\n      endpoints = this._endpoints;\n    }\n\n    return {\n      url: `/${this._route}`,\n      endpoints: unflat({ target: endpoints }),\n    };\n  }\n}\n/**\n * A function to generate a list of middlewares that can be executed before the tontroller\n * main middleware.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerGetMiddlewaresFn = (app: Jimpex) => MiddlewareLike[];\n/**\n * The options for the controller creator that mounts the {@link GatewayController}.\n *\n * @group Controllers/Gateway\n */\nexport type GatewayControllerCreatorOptions =\n  DeepPartial<GatewayControllerExtraOptions> & {\n    /**\n     * The name the creator will use to register the controller in the container. No,\n     * this is not a typo. The creator will register the controller so other services can\n     * access the `getAPIConfig` method. The service will be available after the app\n     * routes are mounted.\n     * If this is overwritten, the creator will ensure that the name ends with `Gateway`;\n     * and if overwritten, but it doesn't include `Gateway` at the end, and no\n     * `gatewaySettingName` was defined, the creator will use the custom name (without\n     * `Gatway`) for `gatewaySettingName`.\n     *\n     * @default 'apiGateway'\n     */\n    serviceName?: string;\n    /**\n     * The name of the helper service the creator will try to obtain from the container.\n     * If `serviceName` is overwritten, the default for this will be\n     * `${serviceName}Helper`.\n     *\n     * @default 'apiGatewayHelper'\n     */\n    helperServiceName?: string;\n    /**\n     * The name of the configuration setting where the gateway configuration is stored. If\n     * not overwritten, check the description of `serviceName` to understand which will be\n     * its default value.\n     *\n     * @default 'api'\n     */\n    gatewaySettingName?: string;\n    /**\n     * The class the creator will instantiate. Similar to the API Client, this allows for\n     * extra customization as you can send a custom subclass of the\n     * {@link GatewayController}.\n     *\n     * @default GatewayController\n     */\n    gatewayClass?: typeof GatewayController;\n    /**\n     * A function to generate a list of middlewares that can be executed before the\n     * controller main middleware.\n     */\n    getMiddlewares?: GatewayControllerGetMiddlewaresFn;\n  };\n/**\n * Creates a controller that allows the application to mount routes that will work like\n * gateway to a specific API.\n *\n * @group Controllers\n * @group Controllers/Gateway\n */\nexport const gatewayController = controllerProviderCreator(\n  (options: GatewayControllerCreatorOptions = {}) =>\n    (app, route) => {\n      /**\n       * Formats the name in order to keep consistency with the helper service and the\n       * configuration setting: If the `serviceName` is different from the default, make\n       * sure it ends with `Gateway`, set the default helper service name to\n       * `${serviceName}Helper`, and the default configuration setting to the same as the\n       * service name (without the `Gateway`).\n       * This way, if you just use `myApi`, the service name will be `myApiGateway`, the\n       * helper name will be `myApiGatewayHelper` and the configuration setting `myApi`.\n       */\n      const defaultServiceName = 'apiGateway';\n      let defaultHelperServiceName = 'apiGatewayHelper';\n      let defaultConfigSetting = 'api';\n      let { serviceName = defaultServiceName } = options;\n      if (serviceName !== defaultServiceName) {\n        defaultConfigSetting = serviceName;\n        if (!serviceName.match(/gateway$/i)) {\n          serviceName = `${serviceName}Gateway`;\n        }\n        defaultHelperServiceName = `${serviceName}Helper`;\n      }\n      // Register the service.\n      app.set(serviceName, () => {\n        const {\n          helperServiceName = defaultHelperServiceName,\n          gatewaySettingName = defaultConfigSetting,\n          gatewayClass: GatewayClass = GatewayController,\n        } = options;\n\n        const gtConfig = app.getConfig<GatewayConfig>(gatewaySettingName);\n\n        return new GatewayClass({\n          ...options,\n          apiConfigSetting: gatewaySettingName,\n          gatewayConfig: gtConfig,\n          route,\n          inject: {\n            http: app.get('http'),\n            getHelperService: () => app.try(helperServiceName),\n          },\n        });\n      });\n\n      return controller(() => {\n        // Get the controller.\n        const ctrl = app.get<GatewayController>(serviceName);\n        /**\n         * Check if there are actual middlewares to be included, and in case there are\n         * Jimpex middlewares, connect them.\n         */\n        let useMiddlewares: ExpressMiddleware[] | undefined;\n        if (options.getMiddlewares) {\n          useMiddlewares = options\n            .getMiddlewares(app)\n            .map((middleware) => {\n              if ('middleware' in middleware) {\n                return middleware.connect(app) as ExpressMiddleware | undefined;\n              }\n\n              return middleware as ExpressMiddleware;\n            })\n            .filter(notUndefined);\n        }\n\n        // Add the routes to the router and return it.\n        return ctrl.addRoutes(app.get('router'), useMiddlewares);\n      });\n    },\n);\n"],"mappings":"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","names":[]}

package/dist/controllers/utils/index.d.ts

@@ -0,0 +1,16 @@
+export { AddGatewayRouteOptions, GatewayConfig, GatewayConfigEndpointDefinition, GatewayConfigEndpointProps, GatewayConfigEndpoints, GatewayController, GatewayControllerAPIConfig, GatewayControllerAPIConfigOptions, GatewayControllerConstructorOptions, GatewayControllerCreatorOptions, GatewayControllerEndpointInfo, GatewayControllerExtraOptions, GatewayControllerGetMiddlewaresFn, GatewayControllerHeaderOptions, GatewayControllerHelperOptions, GatewayControllerOptions, GatewayControllerRequest, GatewayControllerRoute, GatewayControllerRouteMethod, GatewayHelperService, GatewayHelperServiceBaseFnOptions, GatewayHelperServiceErrorHandler, GatewayHelperServiceErrorHandlerOptions, GatewayHelperServiceRequestReducer, GatewayHelperServiceRequestReducerOptions, GatewayHelperServiceResponseHandler, GatewayHelperServiceResponseReducer, GatewayHelperServiceResponseReducerOptions, GatewayHelperServiceStreamVerification, gatewayController } from './gateway.js';
+import '@homer0/jimple';
+import '../../jimpex-7eaee271.js';
+import '@homer0/events-hub';
+import '../../types/express.js';
+import 'express';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '@homer0/simple-config';
+import '../../types/utils.js';
+import '@homer0/simple-logger';
+import '@homer0/api-utils';
+import '../../services/http/http.js';

package/dist/controllers/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./gateway"), module.exports);
+//# sourceMappingURL=index.js.map

package/dist/controllers/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/controllers/utils/index.ts"],"sourcesContent":["export * from './gateway';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,sBAAd;","names":[]}

package/dist/esm/app/index.js

@@ -0,0 +1,2 @@
+export * from "./jimpex";
+//# sourceMappingURL=index.js.map

package/dist/esm/app/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/app/index.ts"],"sourcesContent":["export * from './jimpex';\n"],"mappings":"AAAA,cAAc;","names":[]}