jimpex 8.0.0 → 10.0.0

package/dist/controllers/utils/gateway.d.mts

@@ -0,0 +1,725 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex, a1 as MiddlewareLike, C as ControllerConnectFn, K as ControllerProviderRegisterFn } from '../../index-Bwf7JHu9.mjs';
+import { APIClientOptions } from '@homer0/api-utils';
+import { RouterMethod, AsyncExpressMiddleware, ExpressMiddleware } from '../../types/express.mjs';
+import { Response as Response$1 } from 'node-fetch';
+import { DeepPartial } from '../../types/utils.mjs';
+import { HTTPFetchOptions, HTTP } from '../../services/http/http.mjs';
+import { Request, Response, NextFunction, Router } from 'express';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+
+/**
+ * The extended definition for endpoints.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayConfigEndpointProps = {
+    /**
+     * The path to the endpoint relative to the entry point. It can include placeholders for
+     * parameters like `/:parameter/`.
+     */
+    path: string;
+    /**
+     * The router (HTTP) method for the endpoint.
+     *
+     * @default 'all'
+     */
+    method?: RouterMethod;
+};
+/**
+ * The definition of an endpoint: it can be just the path, relative to the entry point, or
+ * an object in which you can also specify things like the method.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayConfigEndpointDefinition = string | GatewayConfigEndpointProps;
+/**
+ * The dictionary of endpoints the controller uses. The reason for this type is that this
+ * could be a flat dictionary, or a nested one.
+ *
+ * @example
+ *
+ * <caption>A flat dictionary</caption>
+ *
+ * {
+ *   random: '/random',
+ *   users: '/users',
+ *   userById: {
+ *     path: '/users/:id',
+ *     method: 'get',
+ *   },
+ * }
+ *
+ * @example
+ *
+ * <caption>A nested dictionary</caption>
+ *
+ * {
+ *   random: '/random',
+ *   users: {
+ *     list: '/users',
+ *     byId: {
+ *       path: '/users/:id',
+ *       method: 'get',
+ *     },
+ *   },
+ * }
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayConfigEndpoints = {
+    [key: string]: GatewayConfigEndpointDefinition | GatewayConfigEndpoints;
+};
+/**
+ * The configuration for the gateway the controller uses.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayConfig = {
+    /**
+     * The entry point to the API the controller will make the requests to.
+     */
+    url: string;
+    /**
+     * The dictionary of enpoints the gateway will make available.
+     */
+    gateway: GatewayConfigEndpoints;
+};
+/**
+ * The options for how the gateway will handle the headers from the requests and the
+ * responses.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerHeaderOptions = {
+    /**
+     * Whether or not to include the header with the request's IP address.
+     *
+     * @default true
+     */
+    useXForwardedFor: boolean;
+    /**
+     * Whether or not to copy all custom headers from the request. By custom header, it
+     * means all the headers which names start with `x-`.
+     *
+     * @default true
+     */
+    copyCustomHeaders: boolean;
+    /**
+     * A list of "known" headers the gateway will try to copy from the incoming request.
+     *
+     * @default ['authorization','content-type', 'referer', 'user-agent']
+     */
+    copy: string[];
+    /**
+     * A list of "known" headers the gateway will try to remove the response.
+     *
+     * @default ['server', 'x-powered-by']
+     */
+    remove: string[];
+};
+/**
+ * The extra options for the gateway controller. They are "extra" because they are mostly
+ * helpers for when used with an API client, or for optional features.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerExtraOptions = {
+    /**
+     * This is really a helper for when the gateway is used with an API client. The idea is
+     * that, by default, the routes are mounted on the controller route, but with this
+     * option, you can specify another sub path. For example: The controller is mounted on
+     * `/routes`, and if you set `root` to `gateway`, all the routes will be on
+     * `/routes/gateway`.
+     *
+     * This become important (and useful) when you get the API client configuration (with
+     * `getAPIConfig`): The `url` will be the controller route, but all the endpoints will
+     * be modified and prefixed with the `root`, that way, you can have multiple gateways in
+     * the same "base route".
+     *
+     * It can also includes placeholders for parameters like `/:parameter/`, that will be
+     * replaced with the `placeholders` option when `getAPIConfig` gets called.
+     *
+     * @default ''
+     */
+    root: string;
+    /**
+     * This is another option for when the gateway is used with an API client. When calling
+     * `getAPIConfig`, all the endpoints will be wrapped inside an object named after this
+     * option. For example: `{ url: '...', endpoints: { api: { ... } } }`.
+     *
+     * @default 'api'
+     */
+    apiConfigSetting: string;
+    /**
+     * The options for how the gateway will handle the headers from the requests and the
+     * responses.
+     */
+    headers: GatewayControllerHeaderOptions;
+};
+/**
+ * The required options for the gateway controller.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerOptions = {
+    /**
+     * The configuration for the API the gateway will make the requests to.
+     */
+    gatewayConfig: GatewayConfig;
+    /**
+     * The route where the controller is mounted.
+     */
+    route: string;
+} & DeepPartial<GatewayControllerExtraOptions>;
+/**
+ * The information for a request the controller will make.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerRequest = {
+    /**
+     * The URL for the request.
+     */
+    url: string;
+    /**
+     * The options for the fetch client that will make the requests.
+     */
+    options: HTTPFetchOptions;
+};
+/**
+ * The information for an endpoint the gateway is calling.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerEndpointInfo = {
+    /**
+     * The name of the endpoint in the configuration.
+     */
+    name: string;
+    /**
+     * The properties (path and method) of the endpoint.
+     */
+    definition: GatewayConfigEndpointDefinition;
+};
+/**
+ * These are the base options sent to all the helper service functions.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayHelperServiceBaseFnOptions = {
+    /**
+     * The information of the endpoint the gateway is calling.
+     */
+    endpoint: GatewayControllerEndpointInfo;
+    /**
+     * The request recived by the application.
+     */
+    req: Request;
+    /**
+     * The response object created by the application.
+     */
+    res: Response;
+    /**
+     * The function to call the next middleware in the chain.
+     */
+    next: NextFunction;
+};
+/**
+ * The information sent to the helper service in order to modify, or not, a request before
+ * it is sent.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayHelperServiceRequestReducerOptions = GatewayHelperServiceBaseFnOptions & {
+    /**
+     * The options the controller created for the fetch client.
+     */
+    endpointReq: GatewayControllerRequest;
+};
+/**
+ * A function that can be used to modify the information of an endpoint before making a
+ * request.
+ *
+ * @param options  The information of the request.
+ * @group Controllers/Gateway
+ */
+type GatewayHelperServiceRequestReducer = (options: GatewayHelperServiceRequestReducerOptions) => Promise<GatewayControllerRequest>;
+/**
+ * The information sent to the helper service in order to modify a response before
+ * processing it, decide if it should be streamed or not, and even handle it.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayHelperServiceResponseReducerOptions = GatewayHelperServiceBaseFnOptions & {
+    /**
+     * The response from the endpoint request.
+     */
+    endpointRes: Response$1;
+};
+/**
+ * A function that can be used to modify the response of an endpoint before the controller
+ * processes it.
+ *
+ * @param options  The information of the response.
+ * @group Controllers/Gateway
+ */
+type GatewayHelperServiceResponseReducer = (options: GatewayHelperServiceResponseReducerOptions) => Promise<Response$1>;
+/**
+ * A function that can be used to tell the controller to stream the response of an
+ * endpoint or not.
+ * If it returns `false`, the function to handle responses should be defined, otherwise,
+ * an error will be generated.
+ *
+ * @param options  The information of the response.
+ * @group Controllers/Gateway
+ */
+type GatewayHelperServiceStreamVerification = (options: GatewayHelperServiceResponseReducerOptions) => Promise<boolean>;
+/**
+ * A function to handle the response of an endpoint. This is called when the helper
+ * service tells the controller that the endpoint shouldn't be streamed, so this method
+ * should handle the response.
+ *
+ * @param options  The information of the response.
+ * @group Controllers/Gateway
+ */
+type GatewayHelperServiceResponseHandler = (options: GatewayHelperServiceResponseReducerOptions) => Promise<void>;
+/**
+ * The information sent to the helper service in order to handle a failed request for an
+ * endpoint.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayHelperServiceErrorHandlerOptions = GatewayHelperServiceBaseFnOptions & {
+    /**
+     * The error generated during the request.
+     */
+    error: Error;
+};
+/**
+ * A function to handle the error of an endpoint request.
+ *
+ * @param options  The information of the error.
+ * @group Controllers/Gateway
+ */
+type GatewayHelperServiceErrorHandler = (options: GatewayHelperServiceErrorHandlerOptions) => void;
+/**
+ * The interface of a helper service that can intercept/modify the requests and responses
+ * the gateway makes.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayHelperService = Partial<{
+    /**
+     * A function that is called before an endpoint request is made.
+     */
+    reduceEndpointRequest: GatewayHelperServiceRequestReducer;
+    /**
+     * A function that is called with the response of an endpoint request.
+     */
+    reduceEndpointResponse: GatewayHelperServiceResponseReducer;
+    /**
+     * A function called in order to validate if an endpoint response should be streamed or
+     * not. If the function returns `false`, `handleEndpointResponse` will be called.
+     */
+    shouldStreamEndpointResponse: GatewayHelperServiceStreamVerification;
+    /**
+     * A function called when `shouldStreamEndpointResponse` returns `false`. The function
+     * should handle the response for the application.
+     */
+    handleEndpointResponse: GatewayHelperServiceResponseHandler;
+    /**
+     * A function called when an error is generated during an endpoint request/processing.
+     */
+    handleEndpointError: GatewayHelperServiceErrorHandler;
+}>;
+/**
+ * Utility type for the options object sent to the "proxy methods" the controller has for
+ * the helper service.
+ *
+ * @template T  The type of the options for a specific helper service function.
+ * @access protected
+ * @group Controllers/Gateway
+ */
+type GatewayControllerHelperOptions<T> = T & {
+    /**
+     * The reference for the helper service.
+     */
+    helper: GatewayHelperService;
+};
+/**
+ * The information for a single HTTP method an endpoint can handle.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerRouteMethod = {
+    /**
+     * The method for the route.
+     */
+    method: RouterMethod;
+    /**
+     * The information of the endpoint.
+     */
+    endpoint: GatewayControllerEndpointInfo;
+};
+/**
+ * The information for all the HTTP methods that can be handled for an endpoint.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerRoute = {
+    /**
+     * The path to the endpoint, relative to the entry point.
+     */
+    path: string;
+    /**
+     * The path for the route in the controller. This is different from `path` as it's possible for
+     * the gateway to be implemented using the `root` option.
+     */
+    route: string;
+    /**
+     * A list with all the methods the controller uses on the route.
+     */
+    methods: GatewayControllerRouteMethod[];
+};
+/**
+ * The API client configuration the gateway can generate for its endpoints.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerAPIConfig = {
+    /**
+     * The base URL for the API.
+     */
+    url: string;
+    /**
+     * The dictionary of endpoints the controller handles.
+     */
+    endpoints: APIClientOptions['endpoints'];
+};
+/**
+ * The options sent to {@link GatewayController.getAPIConfig}.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerAPIConfigOptions = {
+    /**
+     * This can be used to overwrite the gateway's `apiConfigSetting` option, and set a new
+     * setting as a wrapper for the endpoints.
+     */
+    setting?: string;
+    /**
+     * A dictionary of values for possible placeholders that were sent using the `root`
+     * option.
+     */
+    placeholders?: Record<string, string>;
+};
+/**
+ * The options to construct a {@link GatewayController}.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerConstructorOptions = GatewayControllerOptions & {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        http: HTTP;
+        /**
+         * A function to get a possible helper service. This is injected as a "getter" to not
+         * interrupt the DIC "lifecycle": controllers are initialized right when the app
+         * starts, and injecting a reference would force the service to be initialized too,
+         * even if a request is not being made.
+         */
+        getHelperService?: () => GatewayHelperService | undefined;
+    };
+};
+/**
+ * The options for {@link GatewayController._addRoute}.
+ *
+ * @access protected
+ * @group Controllers/Gateway
+ */
+type AddGatewayRouteOptions = {
+    /**
+     * The reference for the router in which the middlewares will be added.
+     */
+    router: Router;
+    /**
+     * The router method in which the middlewares will be added.
+     */
+    method: RouterMethod;
+    /**
+     * The route in which the middlewares will be added.
+     */
+    route: string;
+    /**
+     * The middleware created by {@link GatewayController}, that makes the request.
+     */
+    gatewayMiddleware: AsyncExpressMiddleware;
+    /**
+     * A list of extra middlewares to prepend to the gateway middleware.
+     */
+    middlewares: ExpressMiddleware[];
+};
+/**
+ * A utility controller that generates routes that act as a gateway for a specific API.
+ *
+ * @group Controller Classes
+ * @group Controllers/Gateway
+ * @prettierignore
+ */
+declare class GatewayController {
+    /**
+     * The service that makes HTTP requests.
+     */
+    protected readonly http: HTTP;
+    /**
+     * A function to get a possible helper service. This is injected as a "getter" to not
+     * interrupt the DIC "lifecycle": controllers are initialized right when the app
+     * starts, and injecting a reference would force the service to be initialized too,
+     * even if a request is not being made.
+     */
+    protected readonly _getHelperService: () => GatewayHelperService | undefined;
+    /**
+     * The information, url and endpoints, for the gateway the controller will make requests to.
+     */
+    protected readonly _gatewayConfig: GatewayConfig;
+    /**
+     * The route in which the controller is mounted.
+     */
+    protected readonly _route: string;
+    /**
+     * A regular expression that will be used to remove the controller route from a
+     * request path. This will allow the main middleware to extract the path to where the
+     * request should be made.
+     */
+    protected readonly _routeExpression: RegExp;
+    /**
+     * The controller customization options.
+     */
+    protected readonly _options: GatewayControllerExtraOptions;
+    /**
+     * A flat dictionary with the endpoints information.
+     */
+    protected readonly _endpoints: Record<string, GatewayConfigEndpointDefinition>;
+    /**
+     * The entry URL for the API client configuration the controller can generate.
+     */
+    protected readonly _apiConfigUrl: string;
+    /**
+     * The generated endpoints for the API client configuration the controller can generate.
+     */
+    protected readonly _apiConfigEndpoints: APIClientOptions['endpoints'];
+    /**
+     * The list of routes the controller can handle.
+     */
+    protected readonly _routes: GatewayControllerRoute[];
+    /**
+     * @param options  The options to construct the controller.
+     */
+    constructor({ inject, route, gatewayConfig, ...options }: GatewayControllerConstructorOptions);
+    /**
+     * Generates an API client configuration based on the controller routes.
+     *
+     * @param options  The options to customize the generated configuration.
+     */
+    getAPIConfig({ setting, placeholders, }?: GatewayControllerAPIConfigOptions): Readonly<GatewayControllerAPIConfig>;
+    /**
+     * Mounts the middlewares in the router in order to make the requests.
+     *
+     * @param router       A reference to the application router.
+     * @param middlewares  A list of extra middlewares to execute before the gateway
+     *                     middleware.
+     */
+    addRoutes(router: Router, middlewares?: ExpressMiddleware[]): Router;
+    /**
+     * The customization options.
+     */
+    get options(): Readonly<GatewayControllerExtraOptions>;
+    /**
+     * The configuration for the gateway the controller will make requests to.
+     */
+    get gatewayConfig(): Readonly<GatewayConfig>;
+    /**
+     * Generates a middleware that will make the request to an endpoint and stream the
+     * response.
+     *
+     * @param endpoint  The information of the endpoint the middleware will handle.
+     */
+    protected _createGatewayMiddleware(endpoint: GatewayControllerEndpointInfo): AsyncExpressMiddleware;
+    /**
+     * Mounts the middleware(s) for an endpoint in the router.
+     *
+     * @param options  The information of the endpoint and how it needs to be added.
+     */
+    protected _addRoute({ router, method, route, gatewayMiddleware, middlewares, }: AddGatewayRouteOptions): void;
+    /**
+     * Formats the endpoints for the gateway into a flat dictionary without nesting.
+     */
+    protected _formatEndpoints(): Record<string, GatewayConfigEndpointDefinition>;
+    /**
+     * Based on the information from the endpoints, this method will create the routes the
+     * controller will later add on a router.
+     *
+     * @throws If there's more than one endpoint using the same path with the same HTTP
+     *         method.
+     */
+    protected _createRoutes(): GatewayControllerRoute[];
+    /**
+     * This is a "proxy method" to call the helper service's function that can modify an
+     * endpoint request before it gets made.
+     *
+     * The reason this is a "proxy method" is in case the controller gets subclassed and
+     * "used itself as a helper" instead of relying on a difference one.
+     *
+     * If the helper doesn't implement `reduceEndpointRequest`, it will just return
+     * information for the request.
+     *
+     * @param options  The information of the request and the reference to the helper.
+     */
+    protected _reduceEndpointRequest({ helper, ...options }: GatewayControllerHelperOptions<GatewayHelperServiceRequestReducerOptions>): Promise<GatewayControllerRequest>;
+    /**
+     * This is a "proxy method" to call the helper service's function that can modify an
+     * endpoint response before it gets processed.
+     *
+     * The reason this is a "proxy method" is in case the controller gets subclassed and
+     * "used itself as a helper" instead of relying on a difference one.
+     *
+     * If the helper doesn't implement `reduceEndpointResponse`, it will just return
+     * information for the response.
+     *
+     * @param options  The information of the response and the reference to the helper.
+     */
+    protected _reduceEndpointResponse({ helper, ...options }: GatewayControllerHelperOptions<GatewayHelperServiceResponseReducerOptions>): Promise<Response$1>;
+    /**
+     * This is a "proxy method" to call the helper service's function that can decide if an
+     * endpoint response should be streamed or not.
+     *
+     * The reason this is a "proxy method" is in case the controller gets subclassed and
+     * "used itself as a helper" instead of relying on a difference one.
+     *
+     * If the helper doesn't implement `shouldStreamEndpointResponse`, it will just return
+     * `true`.
+     *
+     * @param options  The information of the response and the reference to the helper.
+     */
+    protected _shouldStreamEndpointResponse({ helper, ...options }: GatewayControllerHelperOptions<GatewayHelperServiceResponseReducerOptions>): Promise<boolean>;
+    /**
+     * This is a "proxy method" to call the helper service's function that handles a
+     * response in case it already said that a response shouldn't be streamed.
+     *
+     * The reason this is a "proxy method" is in case the controller gets subclassed and
+     * "used itself as a helper" instead of relying on a difference one.
+     *
+     * If the helper doesn't implement `shouldStreamEndpointResponse`, it will throw an
+     * error.
+     *
+     * @param options  The information of the response and the reference to the helper.
+     * @throws If the helper doesn't implement `handleEndpointResponse`.
+     */
+    protected _handleEndpointResponse({ helper, ...options }: GatewayControllerHelperOptions<GatewayHelperServiceResponseReducerOptions>): Promise<void>;
+    /**
+     * This is a "proxy method" to call the helper service's function that handles an error
+     * on an endpoint request.
+     *
+     * The reason this is a "proxy method" is in case the controller gets subclassed and
+     * "used itself as a helper" instead of relying on a difference one.
+     *
+     * If the helper doesn't implement `handleEndpointError`, it will just send the error to
+     * the next middleware/error handler.
+     *
+     * @param options  The information of the response and the reference to the helper.
+     */
+    protected _handleEndpointError({ helper, ...options }: GatewayControllerHelperOptions<GatewayHelperServiceErrorHandlerOptions>): void;
+    /**
+     * Validates and formats the customization options sent to the controller.
+     *
+     * @param options  The options sent to the constructor.
+     */
+    protected _formatOptions(options: GatewayControllerExtraOptions): GatewayControllerExtraOptions;
+    /**
+     * Validates a router/HTTP method that the controller intends to use for an endpoint. If
+     * it's not valid, it will return `all`.
+     *
+     * @param method  The HTTP method for the endpoint.
+     */
+    protected _validateHTTPMethod(method: string): RouterMethod;
+    /**
+     * Creates the API client configuration based on the controller routes.
+     */
+    protected _createAPIConfig(): GatewayControllerAPIConfig;
+}
+/**
+ * A function to generate a list of middlewares that can be executed before the tontroller
+ * main middleware.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerGetMiddlewaresFn = (app: Jimpex) => MiddlewareLike[];
+/**
+ * The options for the controller creator that mounts the {@link GatewayController}.
+ *
+ * @group Controllers/Gateway
+ */
+type GatewayControllerCreatorOptions = DeepPartial<GatewayControllerExtraOptions> & {
+    /**
+     * The name the creator will use to register the controller in the container. No,
+     * this is not a typo. The creator will register the controller so other services can
+     * access the `getAPIConfig` method. The service will be available after the app
+     * routes are mounted.
+     * If this is overwritten, the creator will ensure that the name ends with `Gateway`;
+     * and if overwritten, but it doesn't include `Gateway` at the end, and no
+     * `gatewaySettingName` was defined, the creator will use the custom name (without
+     * `Gatway`) for `gatewaySettingName`.
+     *
+     * @default 'apiGateway'
+     */
+    serviceName?: string;
+    /**
+     * The name of the helper service the creator will try to obtain from the container.
+     * If `serviceName` is overwritten, the default for this will be
+     * `${serviceName}Helper`.
+     *
+     * @default 'apiGatewayHelper'
+     */
+    helperServiceName?: string;
+    /**
+     * The name of the configuration setting where the gateway configuration is stored. If
+     * not overwritten, check the description of `serviceName` to understand which will be
+     * its default value.
+     *
+     * @default 'api'
+     */
+    gatewaySettingName?: string;
+    /**
+     * The class the creator will instantiate. Similar to the API Client, this allows for
+     * extra customization as you can send a custom subclass of the
+     * {@link GatewayController}.
+     *
+     * @default GatewayController
+     */
+    gatewayClass?: typeof GatewayController;
+    /**
+     * A function to generate a list of middlewares that can be executed before the
+     * controller main middleware.
+     */
+    getMiddlewares?: GatewayControllerGetMiddlewaresFn;
+};
+/**
+ * Creates a controller that allows the application to mount routes that will work like
+ * gateway to a specific API.
+ *
+ * @group Controllers
+ * @group Controllers/Gateway
+ */
+declare const gatewayController: _homer0_jimple.ResourceCreator<"provider", "register", (options?: GatewayControllerCreatorOptions) => <ContainerType extends Jimpex = Jimpex>(app: ContainerType, route: string) => _homer0_jimple.Resource<"controller", "connect", ControllerConnectFn>, ControllerProviderRegisterFn>;
+
+export { type AddGatewayRouteOptions, type GatewayConfig, type GatewayConfigEndpointDefinition, type GatewayConfigEndpointProps, type GatewayConfigEndpoints, GatewayController, type GatewayControllerAPIConfig, type GatewayControllerAPIConfigOptions, type GatewayControllerConstructorOptions, type GatewayControllerCreatorOptions, type GatewayControllerEndpointInfo, type GatewayControllerExtraOptions, type GatewayControllerGetMiddlewaresFn, type GatewayControllerHeaderOptions, type GatewayControllerHelperOptions, type GatewayControllerOptions, type GatewayControllerRequest, type GatewayControllerRoute, type GatewayControllerRouteMethod, type GatewayHelperService, type GatewayHelperServiceBaseFnOptions, type GatewayHelperServiceErrorHandler, type GatewayHelperServiceErrorHandlerOptions, type GatewayHelperServiceRequestReducer, type GatewayHelperServiceRequestReducerOptions, type GatewayHelperServiceResponseHandler, type GatewayHelperServiceResponseReducer, type GatewayHelperServiceResponseReducerOptions, type GatewayHelperServiceStreamVerification, gatewayController };