@gravity-ui/gateway 4.1.0 → 4.1.1-alpha.0

package/dist/esm/components/mixed.js

@@ -0,0 +1,62 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { DEFAULT_LANG_HEADER, Lang } from '../constants.js';
+import { handleError } from '../utils/common.js';
+import { generateContextApi } from '../utils/create-context-api.js';
+import { parseMixedError } from '../utils/parse-error.js';
+export function createMixedAction(config, api, serviceName, actionName, extra, ErrorConstructor) {
+    return async (actionConfig) => {
+        const { args } = actionConfig, context = __rest(actionConfig, ["args"]);
+        const ctx = actionConfig.ctx.create(`Gateway ${serviceName} ${actionName} [mixed]`, {
+            tags: {
+                action: actionName,
+                service: serviceName,
+                type: 'mixed',
+            },
+        });
+        const contextApi = generateContextApi(api, Object.assign(Object.assign({}, context), { ctx }));
+        try {
+            const responseData = await config(contextApi, args, Object.assign({ headers: actionConfig.headers, lang: actionConfig.headers[DEFAULT_LANG_HEADER] || Lang.Ru, ctx }, extra));
+            ctx.log('Request completed');
+            return {
+                responseData,
+                debugHeaders: {},
+            };
+        }
+        catch (e) {
+            if (e instanceof Object && 'error' in e) {
+                handleError(ErrorConstructor, e, ctx, 'Request failed', {
+                    actionName,
+                    serviceName,
+                });
+                throw e;
+            }
+            if (e instanceof Error) {
+                const parsedError = parseMixedError(e);
+                handleError(ErrorConstructor, e, ctx, 'Request failed', {
+                    actionName,
+                    serviceName,
+                });
+                throw {
+                    error: parsedError,
+                };
+            }
+            handleError(ErrorConstructor, e, ctx, 'Request failed');
+            throw {
+                error: e,
+            };
+        }
+        finally {
+            ctx.end();
+        }
+    };
+}

package/dist/esm/components/rest.d.ts

@@ -0,0 +1,8 @@
+import { ApiActionConfig, ApiServiceRestActionConfig, EndpointsConfig, GatewayApiOptions, Headers } from '../models/common.js';
+import { GatewayContext } from '../models/context.js';
+import { AppErrorConstructor } from '../models/error.js';
+export declare function createRestAction<Context extends GatewayContext>(endpoints: EndpointsConfig | undefined, config: ApiServiceRestActionConfig<Context, any, any>, serviceKey: string, actionName: string, options: GatewayApiOptions<Context>, ErrorConstructor: AppErrorConstructor): (actionConfig: ApiActionConfig<Context, any>) => Promise<{
+    responseData: unknown;
+    responseHeaders?: Headers;
+    debugHeaders: Headers;
+}>;

package/dist/esm/components/rest.js

@@ -0,0 +1,349 @@
+import querystring from 'querystring';
+import url from 'url';
+import _ from 'lodash';
+import { v4 as uuidv4 } from 'uuid';
+import { DEFAULT_LANG_HEADER, DEFAULT_PROXY_HEADERS, DEFAULT_TIMEOUT, ECMA_STRING_SIZE, Lang, VERSION, } from '../constants.js';
+import { getAxiosClient } from '../utils/axios.js';
+import { handleError, isExtendedActionEndpoint, isExtendedRestActionEndpoint, sanitizeDebugHeaders, } from '../utils/common.js';
+import { parseRestError } from '../utils/parse-error.js';
+import { redactSensitiveHeaders } from '../utils/redact-sensitive-headers.js';
+import { encodePathParams, getPathArgsProxy, validateArgs } from '../utils/validate.js';
+function getRestResponseSize(data, ctx, ErrorConstructor) {
+    var _a;
+    let responseSize = 0;
+    try {
+        responseSize = ECMA_STRING_SIZE * ((_a = JSON.stringify(data)) === null || _a === void 0 ? void 0 : _a.length);
+    }
+    catch (error) {
+        handleError(ErrorConstructor, error, ctx, 'Calculate response size failed');
+    }
+    return responseSize;
+}
+function getConfigSerializerFunction(config) {
+    if (typeof config.paramsSerializer === 'function') {
+        return config.paramsSerializer;
+    }
+    if (config.paramsSerializer && 'serialize' in config.paramsSerializer) {
+        return config.paramsSerializer.serialize;
+    }
+    return undefined;
+}
+export function createRestAction(endpoints, config, serviceKey, actionName, options, ErrorConstructor) {
+    var _a, _b, _c;
+    const timeout = (_c = (_a = config === null || config === void 0 ? void 0 : config.timeout) !== null && _a !== void 0 ? _a : (_b = options === null || options === void 0 ? void 0 : options.axiosConfig) === null || _b === void 0 ? void 0 : _b.timeout) !== null && _c !== void 0 ? _c : options === null || options === void 0 ? void 0 : options.timeout;
+    const defaultAxiosClient = getAxiosClient(timeout, config === null || config === void 0 ? void 0 : config.retries, options === null || options === void 0 ? void 0 : options.axiosConfig, options === null || options === void 0 ? void 0 : options.axiosInterceptors);
+    /* eslint-disable complexity */
+    return async function action(actionConfig) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const { args, requestId, headers: requestHeaders, ctx: parentCtx, authArgs, userId, } = actionConfig;
+        const debugHeaders = {};
+        const lang = requestHeaders[DEFAULT_LANG_HEADER] || Lang.Ru; // header might be empty string
+        const serviceName = (options === null || options === void 0 ? void 0 : options.serviceName) || serviceKey;
+        const idempotency = config.idempotency;
+        const ctx = parentCtx.create(`Gateway ${serviceName} ${actionName} [rest]`, {
+            tags: {
+                action: actionName,
+                service: serviceName,
+                type: 'rest',
+            },
+        });
+        ctx.log('Initiating request');
+        const validationSchema = config.validationSchema || options.validationSchema;
+        if (validationSchema) {
+            const invalidParams = validateArgs(args, validationSchema);
+            if (invalidParams) {
+                ctx.log('Invalid params', { invalidParams });
+                ctx.end();
+                return Promise.reject({
+                    error: {
+                        status: 400,
+                        message: 'Validation failed',
+                        code: 'INVALID_PARAMS',
+                        details: {
+                            title: 'Invalid params',
+                            description: invalidParams,
+                        },
+                    },
+                    debugHeaders,
+                });
+            }
+        }
+        let endpointData = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpoint;
+        if (typeof config.endpoint === 'function') {
+            endpointData = config.endpoint(endpoints, args);
+        }
+        else if (config.endpoint) {
+            endpointData = _.get(endpoints, [config.endpoint]);
+        }
+        if (!endpointData) {
+            const errorText = `Gateway config error. Endpoint has been not found in service "${serviceKey}"`;
+            ctx.log(errorText, { serviceName, actionName });
+            ctx.end();
+            return Promise.reject({
+                error: {
+                    status: 400,
+                    code: 'ENDPOINT_NOT_FOUND',
+                    message: errorText,
+                },
+            });
+        }
+        const actionEndpoint = isExtendedActionEndpoint(endpointData)
+            ? endpointData.path
+            : endpointData;
+        const endpointAxiosConfig = isExtendedRestActionEndpoint(endpointData)
+            ? endpointData.axiosConfig
+            : undefined;
+        const pathArgs = config.validationSchema
+            ? encodePathParams(args)
+            : getPathArgsProxy(args, options.encodePathArgs);
+        const actionPath = typeof config.path === 'function' ? config.path(pathArgs) : config.path;
+        const actionURL = actionEndpoint + actionPath;
+        const parsedActionURL = url.parse(actionURL);
+        const proxyHeaders = [...DEFAULT_PROXY_HEADERS];
+        let actionHeaders = {
+            // It's important not to lose the port in HOST header
+            host: (_a = parsedActionURL.host) !== null && _a !== void 0 ? _a : undefined,
+            accept: 'application/json, */*',
+            'accept-encoding': 'gzip, deflate',
+            'accept-language': lang,
+            'x-gateway-version': VERSION,
+        };
+        if (typeof options.proxyHeaders === 'function') {
+            Object.assign(actionHeaders, options.proxyHeaders(Object.assign({}, requestHeaders), 'rest'));
+        }
+        else if (Array.isArray(options.proxyHeaders)) {
+            proxyHeaders.push(...options.proxyHeaders);
+        }
+        if (typeof config.proxyHeaders === 'function') {
+            Object.assign(actionHeaders, config.proxyHeaders(Object.assign({}, requestHeaders), 'rest'));
+        }
+        else if (Array.isArray(config.proxyHeaders)) {
+            proxyHeaders.push(...config.proxyHeaders);
+        }
+        for (const headerName of proxyHeaders) {
+            if (actionHeaders[headerName] === undefined) {
+                actionHeaders[headerName] = requestHeaders[headerName];
+            }
+        }
+        if (requestId) {
+            actionHeaders['x-request-id'] = requestId;
+        }
+        if (idempotency) {
+            actionHeaders['idempotency-key'] = requestHeaders['idempotency-key'] || uuidv4();
+        }
+        const authHeaders = ((_b = config.getAuthHeaders) !== null && _b !== void 0 ? _b : options.getAuthHeaders)({
+            actionType: 'rest',
+            serviceName,
+            requestHeaders,
+            authArgs,
+        });
+        Object.assign(actionHeaders, authHeaders);
+        actionHeaders = _.omitBy(actionHeaders, _.isUndefined);
+        let params;
+        if (config.params) {
+            try {
+                params = await config.params(args, actionHeaders, { ctx });
+            }
+            catch (error) {
+                handleError(ErrorConstructor, error, ctx, 'Getting config params failed');
+            }
+        }
+        const { body = undefined, query = undefined, headers = actionHeaders } = params !== null && params !== void 0 ? params : {};
+        let requestBody;
+        const serializer = getConfigSerializerFunction(config);
+        const preparedQuery = serializer && query ? serializer(query) : querystring.stringify(query);
+        const requestUrl = actionURL + (query ? '?' + preparedQuery : '');
+        try {
+            let encodedRequestBody = '';
+            if (body instanceof Buffer) {
+                encodedRequestBody = '[Buffer]';
+            }
+            else {
+                encodedRequestBody = encodeURIComponent(typeof body === 'object' ? JSON.stringify(body) : String(body));
+            }
+            if (encodedRequestBody.length < 256) {
+                requestBody = encodedRequestBody;
+            }
+        }
+        catch (error) {
+            handleError(ErrorConstructor, error, ctx, 'Stringify request body failed');
+        }
+        Object.assign(debugHeaders, {
+            'x-api-request-method': config.method,
+            'x-api-request-url': requestUrl,
+            'x-api-request-body': requestBody ? requestBody : null,
+            'x-api-request-lang': lang,
+            'x-request-id': requestId,
+            'x-gateway-version': VERSION,
+        });
+        if (headers['content-type']) {
+            debugHeaders['x-api-content-type'] = headers['content-type'];
+        }
+        if (typeof options.proxyDebugHeaders === 'function') {
+            Object.assign(debugHeaders, options.proxyDebugHeaders(Object.assign({}, requestHeaders), 'rest'));
+        }
+        else if (Array.isArray(options.proxyDebugHeaders)) {
+            for (const headerName of options.proxyDebugHeaders) {
+                if (headers[headerName] !== undefined) {
+                    debugHeaders[`x-gateway-${headerName}`] = headers[headerName];
+                }
+            }
+        }
+        const startRequestTime = Date.now();
+        let axiosClient = defaultAxiosClient;
+        const customActionTimeout = (_e = (_d = (_c = actionConfig.timeout) !== null && _c !== void 0 ? _c : config.timeout) !== null && _d !== void 0 ? _d : endpointAxiosConfig === null || endpointAxiosConfig === void 0 ? void 0 : endpointAxiosConfig.timeout) !== null && _e !== void 0 ? _e : timeout;
+        if (actionConfig.timeout || endpointAxiosConfig) {
+            const customActionAxiosConfig = Object.assign(Object.assign({}, ((options === null || options === void 0 ? void 0 : options.axiosConfig) || {})), (endpointAxiosConfig || {}));
+            axiosClient = getAxiosClient(customActionTimeout, config === null || config === void 0 ? void 0 : config.retries, customActionAxiosConfig, options === null || options === void 0 ? void 0 : options.axiosInterceptors);
+        }
+        headers['x-request-timeout'] = customActionTimeout !== null && customActionTimeout !== void 0 ? customActionTimeout : DEFAULT_TIMEOUT;
+        ctx.log('Starting request', { debugHeaders: sanitizeDebugHeaders(debugHeaders) });
+        const requestData = {
+            timestamp: startRequestTime,
+            service: serviceName,
+            action: actionName,
+            requestId,
+            requestMethod: config.method,
+            requestUrl: actionURL,
+            traceId: ((_f = ctx.getTraceId) === null || _f === void 0 ? void 0 : _f.call(ctx)) || '',
+            userId: userId || '',
+        };
+        const requestConfig = {
+            url: actionURL,
+            method: config.method,
+            data: body,
+            params: query,
+            headers: ctx ? Object.assign(Object.assign({}, ctx.getMetadata()), headers) : headers,
+            maxRedirects: config.maxRedirects,
+        };
+        if (config.paramsSerializer) {
+            Object.assign(requestConfig, {
+                paramsSerializer: config.paramsSerializer,
+            });
+        }
+        if (config.responseType) {
+            Object.assign(requestConfig, {
+                responseType: config.responseType,
+            });
+        }
+        try {
+            const response = await axiosClient.request(requestConfig);
+            const responseHeaders = {};
+            const endRequestTime = Date.now();
+            requestData.requestTime = endRequestTime - startRequestTime;
+            const actualResponseContentType = (_g = response.headers) === null || _g === void 0 ? void 0 : _g['Content-Type'];
+            const expectedResponseContentType = config.expectedResponseContentType || options.expectedResponseContentType;
+            if (actualResponseContentType && expectedResponseContentType) {
+                let isInvalidResponseContentType;
+                if (Array.isArray(expectedResponseContentType)) {
+                    isInvalidResponseContentType = !expectedResponseContentType.includes(String(actualResponseContentType));
+                }
+                else {
+                    isInvalidResponseContentType =
+                        expectedResponseContentType !== actualResponseContentType;
+                }
+                if (isInvalidResponseContentType) {
+                    ctx.log('Invalid response content type', {
+                        expectedResponseContentType,
+                        actualResponseContentType,
+                    });
+                    ctx.end();
+                    return Promise.reject({
+                        error: {
+                            status: 415,
+                            message: 'Response content type validation failed',
+                            code: 'INVALID_RESPONSE_CONTENT_TYPE',
+                            details: {
+                                title: 'Invalid response content type',
+                                description: `Expected to get ${expectedResponseContentType} but got ${actualResponseContentType}`,
+                            },
+                        },
+                        debugHeaders,
+                    });
+                }
+            }
+            if (config.transformResponseData) {
+                try {
+                    response.data = await config.transformResponseData(response.data, {
+                        args,
+                        ctx,
+                        headers: response.headers,
+                    });
+                    ctx.log('Transformed response data');
+                }
+                catch (error) {
+                    handleError(ErrorConstructor, error, ctx, 'Transform response data failed');
+                }
+            }
+            if (config.proxyResponseHeaders) {
+                const proxyResponseHeaders = [];
+                if (typeof config.proxyResponseHeaders === 'function') {
+                    Object.assign(responseHeaders, config.proxyResponseHeaders(Object.assign({}, response.headers), 'rest'));
+                }
+                else if (Array.isArray(config.proxyResponseHeaders)) {
+                    proxyResponseHeaders.push(...config.proxyResponseHeaders);
+                }
+                for (const headerName of proxyResponseHeaders) {
+                    if (responseHeaders[headerName] === undefined) {
+                        responseHeaders[headerName] = response.headers[headerName];
+                    }
+                }
+            }
+            if (options === null || options === void 0 ? void 0 : options.sendStats) {
+                options.sendStats(Object.assign(Object.assign({}, requestData), { responseSize: getRestResponseSize(response === null || response === void 0 ? void 0 : response.data, ctx, ErrorConstructor), restStatus: 200 }), redactSensitiveHeaders(parentCtx, headers), parentCtx, { debugHeaders: sanitizeDebugHeaders(debugHeaders) });
+            }
+            else {
+                ctx.stats(Object.assign(Object.assign({}, requestData), { responseStatus: 200 }));
+            }
+            ctx.log('Request completed', { debugHeaders: sanitizeDebugHeaders(debugHeaders) });
+            ctx.end();
+            return { responseData: response.data, responseHeaders, debugHeaders };
+        }
+        catch (error) {
+            let parsedError;
+            const endRequestTime = new Date().getTime();
+            requestData.requestTime = endRequestTime - startRequestTime;
+            if (error &&
+                error instanceof Object &&
+                'response' in error &&
+                config.transformResponseError) {
+                try {
+                    parsedError = await config.transformResponseError(error.response, {
+                        args,
+                        ctx,
+                    });
+                    ctx.log('Transformed response error');
+                }
+                catch (error) {
+                    handleError(ErrorConstructor, error, ctx, 'Transform response error failed');
+                }
+            }
+            if (!parsedError) {
+                try {
+                    parsedError = parseRestError(error, lang);
+                }
+                catch (error) {
+                    handleError(ErrorConstructor, error, ctx, 'Error parse rest error');
+                }
+            }
+            const responseStatus = _.get(parsedError, 'status') || _.get(error, 'status', 500);
+            if (options === null || options === void 0 ? void 0 : options.sendStats) {
+                options.sendStats(Object.assign(Object.assign({}, requestData), { responseSize: getRestResponseSize((_h = error === null || error === void 0 ? void 0 : error.response) === null || _h === void 0 ? void 0 : _h.data, ctx, ErrorConstructor), restStatus: responseStatus, userId }), redactSensitiveHeaders(parentCtx, headers), parentCtx, { debugHeaders: sanitizeDebugHeaders(debugHeaders) });
+            }
+            else {
+                ctx.stats(Object.assign(Object.assign({}, requestData), { responseStatus }));
+            }
+            ctx.logError('Request failed', error, {
+                actionURL,
+                parsedError,
+                serviceName,
+                debugHeaders: sanitizeDebugHeaders(debugHeaders),
+            });
+            ctx.end();
+            return Promise.reject({
+                error: Object.assign(Object.assign({}, parsedError), { requestId }),
+                debugHeaders,
+            });
+        }
+    };
+}

package/dist/esm/constants.d.ts

@@ -0,0 +1,53 @@
+import * as http from 'http';
+import * as https from 'https';
+import * as grpc from '@grpc/grpc-js';
+export declare const VERSION: any;
+export declare enum Lang {
+    Ru = "ru",
+    En = "en"
+}
+export declare const DEFAULT_TIMEOUT: number;
+export declare const DEFAULT_LANG_HEADER = "accept-language";
+export declare const DEFAULT_PROXY_HEADERS: string[];
+export declare const DEFAULT_AXIOS_OPTIONS: {
+    maxContentLength: number;
+    httpAgent: http.Agent;
+    httpsAgent: https.Agent;
+};
+export declare const DEFAULT_GRPC_OPTIONS: {
+    'grpc.max_receive_message_length': number;
+    'grpc.keepalive_time_ms': number;
+    'grpc.keepalive_timeout_ms': number;
+    'grpc.keepalive_permit_without_calls': number;
+};
+export declare const DEFAULT_PROTO_LOADER_OPTIONS: {
+    longs: StringConstructor;
+    enums: StringConstructor;
+    defaults: boolean;
+    oneofs: boolean;
+};
+/**
+ * Byte sizes are taken from ECMAScript Language Specification
+ * http://www.ecma-international.org/ecma-262/5.1/
+ */
+export declare const ECMA_STRING_SIZE = 2;
+export declare const ANY_ACTION_SYMBOL = "*";
+export declare const RETRYABLE_STATUS_CODES: Array<grpc.status | undefined>;
+export declare const RECREATE_SERVICE_CODES: Array<grpc.status | undefined>;
+/**
+ * Common validation schema for action's parameters. You can use it in GatewayConfig as validationSchema
+ * Validates the parameter type: only number, object, or string are allowed.
+ * For strings, disallows characters: ".", "?", "#", "/", "\"
+ */
+export declare const DEFAULT_VALIDATION_SCHEMA: {
+    additionalProperties: {
+        oneOf: ({
+            type: string;
+            pattern?: undefined;
+        } | {
+            type: string;
+            pattern: string;
+        })[];
+    };
+};
+export declare const AXIOS_RETRY_NAMESPACE = "axios-retry";

package/dist/esm/constants.js

@@ -0,0 +1,79 @@
+import * as http from 'http';
+import * as https from 'https';
+import * as grpc from '@grpc/grpc-js';
+const packageJson = require('../package.json');
+export const VERSION = packageJson.version;
+export var Lang;
+(function (Lang) {
+    Lang["Ru"] = "ru";
+    Lang["En"] = "en";
+})(Lang || (Lang = {}));
+export const DEFAULT_TIMEOUT = 25 * 1000;
+export const DEFAULT_LANG_HEADER = 'accept-language';
+export const DEFAULT_PROXY_HEADERS = [
+    'origin',
+    'user-agent',
+    'referer',
+    'x-real-ip',
+    'x-forwarded-for',
+];
+export const DEFAULT_AXIOS_OPTIONS = {
+    maxContentLength: 1024 * 1024 * 100, // 100 Mb
+    httpAgent: new http.Agent({
+        // https://github.com/nodejs/node/blob/master/lib/_http_agent.js#L233
+        family: 6,
+    }),
+    httpsAgent: new https.Agent({
+        // https://github.com/nodejs/node/blob/master/lib/_http_agent.js#L233
+        family: 6,
+    }),
+};
+export const DEFAULT_GRPC_OPTIONS = {
+    'grpc.max_receive_message_length': 1024 * 1024 * 100, // 100 Mb
+    'grpc.keepalive_time_ms': 10000,
+    'grpc.keepalive_timeout_ms': 1000,
+    'grpc.keepalive_permit_without_calls': 1,
+};
+export const DEFAULT_PROTO_LOADER_OPTIONS = {
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true,
+};
+/**
+ * Byte sizes are taken from ECMAScript Language Specification
+ * http://www.ecma-international.org/ecma-262/5.1/
+ */
+export const ECMA_STRING_SIZE = 2;
+export const ANY_ACTION_SYMBOL = '*';
+export const RETRYABLE_STATUS_CODES = [
+    grpc.status.UNAVAILABLE,
+    grpc.status.CANCELLED,
+    grpc.status.ABORTED,
+    grpc.status.UNKNOWN,
+];
+export const RECREATE_SERVICE_CODES = [
+    grpc.status.DEADLINE_EXCEEDED,
+];
+/**
+ * Common validation schema for action's parameters. You can use it in GatewayConfig as validationSchema
+ * Validates the parameter type: only number, object, or string are allowed.
+ * For strings, disallows characters: ".", "?", "#", "/", "\"
+ */
+export const DEFAULT_VALIDATION_SCHEMA = {
+    additionalProperties: {
+        oneOf: [
+            {
+                type: 'number',
+            },
+            {
+                type: 'string',
+                pattern: '^((?!(\\.\\.|\\?|#|\\\\|\\/)).)*$',
+            },
+            {
+                type: 'object',
+            },
+        ],
+    },
+};
+export const AXIOS_RETRY_NAMESPACE = 'axios-retry';

package/dist/esm/index.d.ts

@@ -0,0 +1,12 @@
+import { ApiWithRoot, GatewayConfig, GatewayRequest, GatewayResponse, SchemasByScope } from './models/common.js';
+import { GatewayContext } from './models/context.js';
+export * from './utils/typed-api.js';
+export * from './utils/grpc-reflection.js';
+export * from './models/common.js';
+export * from './models/context.js';
+export * from './models/error.js';
+export declare function getGatewayControllers<TSchema extends SchemasByScope, Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse>(schemasByScope: TSchema, config: GatewayConfig<Context, Req, Res>): {
+    controller: (req: Req, res: Res) => Promise<any>;
+    api: ApiWithRoot<TSchema, Context, Req, Res>;
+};
+export default getGatewayControllers;