jimpex 7.0.1 → 8.0.0

package/dist/esm/controllers/common/statics.js

@@ -0,0 +1,173 @@
+import {
+  __publicField
+} from "../../chunk-T2T6Q22Z.js";
+import * as path from "path";
+import * as mime from "mime";
+import { deepAssignWithOverwrite } from "@homer0/deep-assign";
+import {
+  controllerCreator,
+  removeSlashes,
+  notUndefined
+} from "../../utils";
+class StaticsController {
+  constructor({ inject, ...options }) {
+    __publicField(this, "_sendFile");
+    __publicField(this, "_options");
+    __publicField(this, "files");
+    this._sendFile = inject.sendFile;
+    this._options = this._validateOptions(
+      deepAssignWithOverwrite(
+        {
+          files: ["favicon.ico", "index.html"],
+          methods: options.methods || {
+            all: false,
+            get: true
+          },
+          paths: {
+            route: "",
+            source: "./"
+          }
+        },
+        options
+      )
+    );
+    this.files = this._createFiles();
+  }
+  addRoutes(router, middlewares = []) {
+    const { methods } = this._options;
+    const use = methods.all ? ["all"] : Object.keys(methods).reduce((acc, name) => {
+      const methodName = name;
+      if (methods[methodName]) {
+        acc.push(methodName);
+      }
+      return acc;
+    }, []);
+    Object.keys(this.files).forEach((route) => {
+      const file = this.files[route];
+      const fileMiddleware = this._getMiddleware(file);
+      use.forEach(
+        (method) => this._addRoute({ router, method, file, fileMiddleware, middlewares })
+      );
+    });
+    return router;
+  }
+  get options() {
+    return { ...this._options };
+  }
+  _getMiddleware(file) {
+    return (_, res, next) => {
+      const extension = path.parse(file.path).ext.substring(1);
+      const headers = {
+        "Content-Type": mime.getType(extension) || "text/html",
+        ...file.headers
+      };
+      Object.entries(headers).forEach(([key, value]) => {
+        res.setHeader(key, value);
+      });
+      this._sendFile({
+        res,
+        filepath: file.path,
+        next
+      });
+    };
+  }
+  _addRoute({
+    router,
+    method,
+    file,
+    fileMiddleware,
+    middlewares
+  }) {
+    const { route } = file;
+    router[method](route, [...middlewares, fileMiddleware]);
+  }
+  _validateOptions(options) {
+    if (!options.files || !options.files.length) {
+      throw new Error("You need to specify a list of files");
+    }
+    if (!options.methods) {
+      throw new Error("You need to specify which HTTP methods are allowed for the files");
+    }
+    const methods = Object.keys(options.methods);
+    const atLeastOne = methods.some((method) => options.methods[method]);
+    if (!atLeastOne) {
+      throw new Error("You need to enable at least one HTTP method to serve the files");
+    }
+    const allowedMethods = [
+      "all",
+      "get",
+      "head",
+      "post",
+      "patch",
+      "put",
+      "delete",
+      "connect",
+      "options",
+      "trace"
+    ];
+    const invalid = methods.find(
+      (method) => !allowedMethods.includes(method.toLowerCase())
+    );
+    if (invalid) {
+      throw new Error(`${invalid} is not a valid HTTP method`);
+    }
+    const newMethods = methods.reduce((acc, method) => {
+      acc[method.toLowerCase()] = !!options.methods[method];
+      return acc;
+    }, {});
+    return {
+      ...options,
+      methods: newMethods
+    };
+  }
+  _createFiles() {
+    const { files, paths } = this._options;
+    const routePath = removeSlashes(paths.route, false, true);
+    return files.reduce((acc, file) => {
+      let src;
+      let route;
+      let headers;
+      if (typeof file === "object") {
+        ({ route, path: src, headers } = file);
+      } else {
+        src = file;
+        route = file;
+      }
+      src = path.join(paths.source, src);
+      route = removeSlashes(route, true, false);
+      route = `${routePath}/${route}`;
+      acc[route] = {
+        path: src,
+        route,
+        headers: headers || {}
+      };
+      return acc;
+    }, {});
+  }
+}
+const staticsController = controllerCreator(
+  ({ getMiddlewares, ...options } = {}) => (app) => {
+    const router = app.getRouter();
+    const ctrl = new StaticsController({
+      inject: {
+        sendFile: app.get("sendFile")
+      },
+      ...options
+    });
+    let useMiddlewares;
+    if (getMiddlewares) {
+      useMiddlewares = getMiddlewares(app).map((middleware) => {
+        if ("middleware" in middleware) {
+          return middleware.connect(app);
+        }
+        return middleware;
+      }).filter(notUndefined);
+    }
+    return ctrl.addRoutes(router, useMiddlewares);
+  }
+);
+export {
+  StaticsController,
+  staticsController
+};
+//# sourceMappingURL=statics.js.map

package/dist/esm/controllers/common/statics.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/controllers/common/statics.ts"],"sourcesContent":["import * as path from 'path';\nimport * as mime from 'mime';\nimport { deepAssignWithOverwrite } from '@homer0/deep-assign';\nimport {\n  controllerCreator,\n  removeSlashes,\n  notUndefined,\n  type MiddlewareLike,\n} from '../../utils';\nimport type { SendFile } from '../../services';\nimport type { Jimpex } from '../../app';\nimport type { DeepPartial, ExpressMiddleware, Router, RouterMethod } from '../../types';\n/**\n * The definition for each file the controller handles.\n *\n * @group Controllers/Statics\n */\nexport type StaticsControllerFile = {\n  /**\n   * The route, relative to the controller root, to the file.\n   */\n  route: string;\n  /**\n   * The path to the file in the filesystem. Since the file is served using the\n   * {@link SendFile} service, whether the file is relative to the project root or the\n   * application executable depends on how the service is configured (relative to the\n   * executable by default).\n   */\n  path: string;\n  /**\n   * A dictionary of headers for the response.\n   */\n  headers?: Record<string, string>;\n};\n/**\n * These are like \"master paths\" that get prepended to all the file paths and routes the\n * controller use.\n *\n * @group Controllers/Statics\n */\nexport type StaticsControllerPathsOptions = {\n  /**\n   * A custom route to prefix all the file routes with.\n   */\n  route: string;\n  /**\n   * A custom path to prefix all the file paths with.\n   */\n  source: string;\n};\n/**\n * The options to customize the controller.\n *\n * @group Controllers/Statics\n */\nexport type StaticsControllerOptions = {\n  /**\n   * A list of filenames, or definitions for the files to handle.\n   */\n  files: Array<string | StaticsControllerFile>;\n  /**\n   * A dictionary with the allowed router (HTTP) methods the controller can use to serve\n   * the files. If `all` is set to `true`, the rest of the values will be ignored.\n   *\n   * @default {get: true, all: false}\n   */\n  methods: Partial<Record<RouterMethod, boolean>>;\n  /**\n   * The \"master paths\" the controller can use to prefix the file paths and routes.\n   *\n   * @default {route: '', source: './',}\n   */\n  paths: StaticsControllerPathsOptions;\n};\n/**\n * The options to construct a {@link StaticsController}.\n *\n * @group Controllers/Statics\n */\nexport type StaticsControllerConstructorOptions =\n  DeepPartial<StaticsControllerOptions> & {\n    /**\n     * A dictionary with the dependencies to inject.\n     */\n    inject: {\n      sendFile: SendFile;\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/Statics\n */\nexport type StaticsControllerGetMiddlewaresFn = (app: Jimpex) => MiddlewareLike[];\n/**\n * The options for the controller creator that mounts {@link StaticsController}.\n *\n * @group Controllers/Statics\n */\nexport type StaticsControllerCreatorOptions = DeepPartial<StaticsControllerOptions> & {\n  /**\n   * A function to generate a list of middlewares that can be executed before the\n   * tontroller main middleware.\n   */\n  getMiddlewares?: StaticsControllerGetMiddlewaresFn;\n};\n/**\n * The options for {@link StaticsController._addRoute}.\n *\n * @access protected\n * @group Controllers/Statics\n */\nexport type AddStaticRouteOptions = {\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 definition of the file to serve.\n   */\n  file: StaticsControllerFile;\n  /**\n   * The middleware created by {@link StaticsController}, that will serve the file.\n   */\n  fileMiddleware: ExpressMiddleware;\n  /**\n   * A list of extra middlewares to execute before the file middleware.\n   */\n  middlewares: ExpressMiddleware[];\n};\n\n/**\n * The controller class that allows the application to serve specific files from any\n * folder to any route without the need of mounting directories as \"static\".\n *\n * @group Controller Classes\n * @group Controllers/Statics\n * @prettierignore\n */\nexport class StaticsController {\n  /**\n   * The service that serves static files.\n   */\n  protected readonly _sendFile: SendFile;\n  /**\n   * The controller customization options.\n   */\n  protected _options: StaticsControllerOptions;\n  /**\n   * A dictionary with the formatted definitions of the files that will be served.\n   * It uses the files' routes as keys, for easy access in the middleware.\n   */\n  protected files: Record<string, StaticsControllerFile>;\n  /**\n   * @param options  The options to construct the controller.\n   */\n  constructor({ inject, ...options }: StaticsControllerConstructorOptions) {\n    this._sendFile = inject.sendFile;\n    this._options = this._validateOptions(\n      deepAssignWithOverwrite(\n        {\n          files: ['favicon.ico', 'index.html'],\n          methods: options.methods || {\n            all: false,\n            get: true,\n          },\n          paths: {\n            route: '',\n            source: './',\n          },\n        },\n        options,\n      ),\n    );\n    this.files = this._createFiles();\n  }\n  /**\n   * Mounts the middlewares in the router in order to serve the files.\n   *\n   * @param router       A reference to the application router.\n   * @param middlewares  A list of extra middlewares to execute before the file\n   *                     middleware.\n   */\n  addRoutes(router: Router, middlewares: ExpressMiddleware[] = []): Router {\n    const { methods } = this._options;\n    const use: RouterMethod[] = methods.all\n      ? ['all']\n      : Object.keys(methods).reduce<RouterMethod[]>((acc, name) => {\n          const methodName = name as RouterMethod;\n          if (methods[methodName]) {\n            acc.push(methodName);\n          }\n\n          return acc;\n        }, []);\n\n    Object.keys(this.files).forEach((route) => {\n      const file = this.files[route as keyof typeof this.files]!;\n      const fileMiddleware = this._getMiddleware(file);\n      use.forEach((method) =>\n        this._addRoute({ router, method, file, fileMiddleware, middlewares }),\n      );\n    });\n\n    return router;\n  }\n  /**\n   * The controller options.\n   */\n  get options(): Readonly<StaticsControllerOptions> {\n    return { ...this._options };\n  }\n  /**\n   * Generates the middleware that will serve the file.\n   *\n   * @param file  The definition of the file to serve.\n   */\n  protected _getMiddleware(file: StaticsControllerFile): ExpressMiddleware {\n    return (_, res, next) => {\n      const extension = path.parse(file.path).ext.substring(1);\n      const headers = {\n        'Content-Type': mime.getType(extension) || 'text/html',\n        ...file.headers,\n      };\n\n      Object.entries(headers).forEach(([key, value]) => {\n        res.setHeader(key, value);\n      });\n\n      this._sendFile({\n        res,\n        filepath: file.path,\n        next,\n      });\n    };\n  }\n  /**\n   * Mounts the middleware(s) for a file in the router.\n   *\n   * @param options  The information of the file and how it needs to be added.\n   */\n  protected _addRoute({\n    router,\n    method,\n    file,\n    fileMiddleware,\n    middlewares,\n  }: AddStaticRouteOptions): void {\n    const { route } = file;\n    router[method](route, [...middlewares, fileMiddleware]);\n  }\n  /**\n   * Validates and formats the options sent to the constructor in order to get the final\n   * set that will be stored in the controller.\n   *\n   * @param options  The options to validate.\n   * @throws If no files are specified.\n   * @throws If methods is not defined.\n   * @throws If no methods are enabled.\n   * @throws If there's an invalid HTTP method.\n   */\n  protected _validateOptions(\n    options: StaticsControllerOptions,\n  ): StaticsControllerOptions {\n    if (!options.files || !options.files.length) {\n      throw new Error('You need to specify a list of files');\n    }\n\n    if (!options.methods) {\n      throw new Error('You need to specify which HTTP methods are allowed for the files');\n    }\n\n    const methods = Object.keys(options.methods) as RouterMethod[];\n\n    const atLeastOne = methods.some((method) => options.methods[method]);\n    if (!atLeastOne) {\n      throw new Error('You need to enable at least one HTTP method to serve the files');\n    }\n\n    const allowedMethods: RouterMethod[] = [\n      'all',\n      'get',\n      'head',\n      'post',\n      'patch',\n      'put',\n      'delete',\n      'connect',\n      'options',\n      'trace',\n    ];\n\n    const invalid = methods.find(\n      (method) => !allowedMethods.includes(method.toLowerCase() as RouterMethod),\n    );\n\n    if (invalid) {\n      throw new Error(`${invalid} is not a valid HTTP method`);\n    }\n\n    const newMethods = methods.reduce<Record<string, boolean>>((acc, method) => {\n      acc[method.toLowerCase()] = !!options.methods[method];\n      return acc;\n    }, {});\n\n    return {\n      ...options,\n      methods: newMethods,\n    };\n  }\n  /**\n   * Parses the files received from the constructor's options, and formats them into\n   * proper definitions the controller can use.\n   */\n  protected _createFiles(): Record<string, StaticsControllerFile> {\n    const { files, paths } = this._options;\n    const routePath = removeSlashes(paths.route, false, true);\n    return files.reduce<Record<string, StaticsControllerFile>>((acc, file) => {\n      let src;\n      let route;\n      let headers;\n      if (typeof file === 'object') {\n        ({ route, path: src, headers } = file);\n      } else {\n        src = file;\n        route = file;\n      }\n\n      src = path.join(paths.source, src);\n      route = removeSlashes(route, true, false);\n      route = `${routePath}/${route}`;\n      acc[route] = {\n        path: src,\n        route,\n        headers: headers || {},\n      };\n\n      return acc;\n    }, {});\n  }\n}\n/**\n * A controller that allows the application to server specific files from any folder to\n * any route without the need of mounting directories as \"static\" folders.\n *\n * @group Controllers\n * @group Controllers/Statics\n */\nexport const staticsController = controllerCreator(\n  ({ getMiddlewares, ...options }: StaticsControllerCreatorOptions = {}) =>\n    (app) => {\n      const router = app.getRouter();\n      const ctrl = new StaticsController({\n        inject: {\n          sendFile: app.get('sendFile'),\n        },\n        ...options,\n      });\n\n      let useMiddlewares: ExpressMiddleware[] | undefined;\n      if (getMiddlewares) {\n        useMiddlewares = 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      return ctrl.addRoutes(router, useMiddlewares);\n    },\n);\n"],"mappings":"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","names":[]}

package/dist/esm/controllers/index.js

@@ -0,0 +1,3 @@
+export * from "./common";
+export * from "./utils";
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,404 @@
+import {
+  __publicField
+} from "../../chunk-T2T6Q22Z.js";
+import { deepAssignWithOverwrite } from "@homer0/deep-assign";
+import { flat, unflat } from "@homer0/object-utils";
+import {
+  controllerProviderCreator,
+  controller,
+  createRouteExpression,
+  removeSlashes,
+  notUndefined
+} from "../../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 = removeSlashes(route);
+    this._options = this._formatOptions(
+      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: removeSlashes(gatewayConfig.url, false, true)
+    };
+    this._routeExpression = 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 = 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 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 = 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 = 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 = removeSlashes(endpoint);
+          newEndpoint = `${root}/${newEndpoint}`;
+        } else {
+          const endpointPath = removeSlashes(endpoint.path);
+          newEndpoint = {
+            ...endpoint,
+            path: `${root}/${endpointPath}`
+          };
+        }
+        acc[name] = newEndpoint;
+        return acc;
+      }, {});
+    } else {
+      endpoints = this._endpoints;
+    }
+    return {
+      url: `/${this._route}`,
+      endpoints: unflat({ target: endpoints })
+    };
+  }
+}
+const gatewayController = 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 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(notUndefined);
+      }
+      return ctrl.addRoutes(app.get("router"), useMiddlewares);
+    });
+  }
+);
+export {
+  GatewayController,
+  gatewayController
+};
+//# sourceMappingURL=gateway.js.map