@gravity-ui/gateway 1.0.0

package/build/components/mixed.js

@@ -0,0 +1,66 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMixedAction = void 0;
+const constants_1 = require("../constants");
+const common_1 = require("../utils/common");
+const create_context_api_1 = require("../utils/create-context-api");
+const parse_error_1 = require("../utils/parse-error");
+function createMixedAction(config, api, serviceName, actionName, extra, ErrorConctructor) {
+    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 = (0, create_context_api_1.generateContextApi)(api, Object.assign(Object.assign({}, context), { ctx }));
+        try {
+            const responseData = await config(contextApi, args, Object.assign({ headers: actionConfig.headers, lang: actionConfig.headers[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru, ctx }, extra));
+            ctx.log('Request completed');
+            return {
+                responseData,
+                debugHeaders: {},
+            };
+        }
+        catch (e) {
+            if (e instanceof Object && 'error' in e) {
+                (0, common_1.handleError)(ErrorConctructor, e, ctx, 'Request failed', {
+                    actionName,
+                    serviceName,
+                });
+                throw e;
+            }
+            if (e instanceof Error) {
+                const parsedError = (0, parse_error_1.parseMixedError)(e);
+                ctx.logError('Request failed', ErrorConctructor.wrap(e), {
+                    actionName,
+                    serviceName,
+                    parsedError,
+                });
+                throw {
+                    error: parsedError,
+                };
+            }
+            throw {
+                error: JSON.stringify(e),
+            };
+        }
+        finally {
+            ctx.end();
+        }
+    };
+}
+exports.createMixedAction = createMixedAction;

package/build/components/rest.d.ts

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

package/build/components/rest.js

@@ -0,0 +1,291 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const querystring_1 = __importDefault(require("querystring"));
+const url_1 = __importDefault(require("url"));
+const lodash_1 = __importDefault(require("lodash"));
+const uuid_1 = require("uuid");
+const constants_1 = require("../constants");
+const axios_1 = require("../utils/axios");
+const common_1 = require("../utils/common");
+const parse_error_1 = require("../utils/parse-error");
+const redact_sensitive_headers_1 = require("../utils/redact-sensitive-headers");
+const validate_1 = require("../utils/validate");
+function getRestResponseSize(data, ctx, ErrorConctructor) {
+    var _a;
+    let responseSize = 0;
+    try {
+        responseSize = constants_1.ECMA_STRING_SIZE * ((_a = JSON.stringify(data)) === null || _a === void 0 ? void 0 : _a.length);
+    }
+    catch (error) {
+        (0, common_1.handleError)(ErrorConctructor, 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;
+}
+function createRestAction(endpoints, config, serviceKey, actionName, options, ErrorConctructor) {
+    var _a;
+    const timeout = (_a = config === null || config === void 0 ? void 0 : config.timeout) !== null && _a !== void 0 ? _a : options === null || options === void 0 ? void 0 : options.timeout;
+    const defaultAxiosClient = (0, axios_1.getAxiosClient)(timeout, config === null || config === void 0 ? void 0 : config.retries, options === null || options === void 0 ? void 0 : options.axiosConfig);
+    /* eslint-disable complexity */
+    return async function action(actionConfig) {
+        var _a, _b, _c, _d;
+        const { args, requestId, headers: requestHeaders, ctx: parentCtx, authArgs } = actionConfig;
+        const debugHeaders = {};
+        const lang = requestHeaders[constants_1.DEFAULT_LANG_HEADER] || constants_1.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 = (0, validate_1.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 = lodash_1.default.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 = (0, common_1.isExtendedActionEndpoint)(endpointData)
+            ? endpointData.path
+            : endpointData;
+        const endpointAxiosConfig = (0, common_1.isExtendedRestActionEndpoint)(endpointData)
+            ? endpointData.axiosConfig || {}
+            : {};
+        const pathArgs = config.validationSchema
+            ? (0, validate_1.encodePathParams)(args)
+            : (0, validate_1.getPathArgsProxy)(args, options.encodePathArgs);
+        const actionPath = typeof config.path === 'function' ? config.path(pathArgs) : config.path;
+        const actionURL = actionEndpoint + actionPath;
+        const parsedActionURL = url_1.default.parse(actionURL);
+        const proxyHeaders = [...constants_1.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': constants_1.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'] || (0, uuid_1.v4)();
+        }
+        const authHeaders = ((_b = config.getAuthHeaders) !== null && _b !== void 0 ? _b : options.getAuthHeaders)({
+            actionType: 'rest',
+            serviceName,
+            requestHeaders,
+            authArgs,
+        });
+        Object.assign(actionHeaders, authHeaders);
+        actionHeaders = lodash_1.default.omitBy(actionHeaders, lodash_1.default.isUndefined);
+        let params;
+        if (config.params) {
+            try {
+                params = await config.params(args, actionHeaders, { ctx });
+            }
+            catch (error) {
+                (0, common_1.handleError)(ErrorConctructor, 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_1.default.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) {
+            (0, common_1.handleError)(ErrorConctructor, 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': constants_1.VERSION,
+        });
+        if (headers['content-type']) {
+            debugHeaders['x-api-content-type'] = headers['content-type'];
+        }
+        const startRequestTime = Date.now();
+        let axiosClient = defaultAxiosClient;
+        if (actionConfig.timeout || endpointAxiosConfig) {
+            const customActionTimeout = (_c = actionConfig.timeout) !== null && _c !== void 0 ? _c : timeout;
+            const customActionAxiosConfig = Object.assign(Object.assign({}, ((options === null || options === void 0 ? void 0 : options.axiosConfig) || {})), (endpointAxiosConfig || {}));
+            axiosClient = (0, axios_1.getAxiosClient)(customActionTimeout, config === null || config === void 0 ? void 0 : config.retries, customActionAxiosConfig);
+        }
+        ctx.log('Starting request', { debugHeaders: (0, common_1.sanitizeDebugHeaders)(debugHeaders) });
+        const requestData = {
+            timestamp: startRequestTime,
+            service: serviceName,
+            action: actionName,
+            requestId,
+            requestMethod: config.method,
+            requestUrl: actionURL,
+        };
+        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,
+            });
+        }
+        try {
+            const response = await axiosClient.request(requestConfig);
+            const endRequestTime = Date.now();
+            requestData.requestTime = endRequestTime - startRequestTime;
+            if (config.transformResponseData) {
+                try {
+                    response.data = await config.transformResponseData(response.data, {
+                        args,
+                        ctx,
+                        headers: response.headers,
+                    });
+                    ctx.log('Transformed response data');
+                }
+                catch (error) {
+                    (0, common_1.handleError)(ErrorConctructor, error, ctx, 'Transform response data failed');
+                }
+            }
+            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, ErrorConctructor), restStatus: 200 }), (0, redact_sensitive_headers_1.redactSensitiveHeaders)(parentCtx, headers), parentCtx, { debugHeaders: (0, common_1.sanitizeDebugHeaders)(debugHeaders) });
+            }
+            else {
+                ctx.stats(Object.assign(Object.assign({}, requestData), { responseStatus: 200 }));
+            }
+            ctx.log('Request completed', { debugHeaders: (0, common_1.sanitizeDebugHeaders)(debugHeaders) });
+            ctx.end();
+            return { responseData: response.data, 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) {
+                    (0, common_1.handleError)(ErrorConctructor, error, ctx, 'Transform response error failed');
+                }
+            }
+            if (!parsedError) {
+                try {
+                    parsedError = (0, parse_error_1.parseRestError)(error, lang);
+                }
+                catch (error) {
+                    (0, common_1.handleError)(ErrorConctructor, error, ctx, 'Error parse rest error');
+                }
+            }
+            const responseStatus = lodash_1.default.get(parsedError, 'status') || lodash_1.default.get(error, 'status', 500);
+            if (options === null || options === void 0 ? void 0 : options.sendStats) {
+                options.sendStats(Object.assign(Object.assign({}, requestData), { responseSize: getRestResponseSize((_d = error === null || error === void 0 ? void 0 : error.response) === null || _d === void 0 ? void 0 : _d.data, ctx, ErrorConctructor), restStatus: responseStatus }), (0, redact_sensitive_headers_1.redactSensitiveHeaders)(parentCtx, headers), parentCtx, { debugHeaders: (0, common_1.sanitizeDebugHeaders)(debugHeaders) });
+            }
+            else {
+                ctx.stats(Object.assign(Object.assign({}, requestData), { responseStatus }));
+            }
+            ctx.logError('Request failed', error, {
+                actionURL,
+                parsedError,
+                serviceName,
+                debugHeaders: (0, common_1.sanitizeDebugHeaders)(debugHeaders),
+            });
+            ctx.end();
+            return Promise.reject({
+                error: Object.assign(Object.assign({}, parsedError), { requestId }),
+                debugHeaders,
+            });
+        }
+    };
+}
+exports.default = createRestAction;

package/build/constants.d.ts

@@ -0,0 +1,46 @@
+import http from 'http';
+import 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;
+};
+/**
+ * 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;
+        })[];
+    };
+};

package/build/constants.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_VALIDATION_SCHEMA = exports.RECREATE_SERVICE_CODES = exports.RETRYABLE_STATUS_CODES = exports.ANY_ACTION_SYMBOL = exports.ECMA_STRING_SIZE = exports.DEFAULT_GRPC_OPTIONS = exports.DEFAULT_AXIOS_OPTIONS = exports.DEFAULT_PROXY_HEADERS = exports.DEFAULT_LANG_HEADER = exports.DEFAULT_TIMEOUT = exports.Lang = exports.VERSION = void 0;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const grpc = __importStar(require("@grpc/grpc-js"));
+const packageJson = require('../package.json');
+exports.VERSION = packageJson.version;
+var Lang;
+(function (Lang) {
+    Lang["Ru"] = "ru";
+    Lang["En"] = "en";
+})(Lang || (exports.Lang = Lang = {}));
+exports.DEFAULT_TIMEOUT = 25 * 1000;
+exports.DEFAULT_LANG_HEADER = 'accept-language';
+exports.DEFAULT_PROXY_HEADERS = [
+    'origin',
+    'user-agent',
+    'referer',
+    'x-real-ip',
+    'x-forwarded-for',
+];
+exports.DEFAULT_AXIOS_OPTIONS = {
+    maxContentLength: 1024 * 1024 * 100,
+    httpAgent: new http_1.default.Agent({
+        //@ts-ignore https://github.com/nodejs/node/blob/master/lib/_http_agent.js#L233
+        family: 6,
+    }),
+    httpsAgent: new https_1.default.Agent({
+        //@ts-ignore https://github.com/nodejs/node/blob/master/lib/_http_agent.js#L233
+        family: 6,
+    }),
+};
+exports.DEFAULT_GRPC_OPTIONS = {
+    'grpc.max_receive_message_length': 1024 * 1024 * 100,
+    'grpc.keepalive_time_ms': 10000,
+    'grpc.keepalive_timeout_ms': 1000,
+    'grpc.keepalive_permit_without_calls': 1,
+};
+/**
+ * Byte sizes are taken from ECMAScript Language Specification
+ * http://www.ecma-international.org/ecma-262/5.1/
+ */
+exports.ECMA_STRING_SIZE = 2;
+exports.ANY_ACTION_SYMBOL = '*';
+exports.RETRYABLE_STATUS_CODES = [
+    grpc.status.UNAVAILABLE,
+    grpc.status.CANCELLED,
+    grpc.status.ABORTED,
+    grpc.status.UNKNOWN,
+];
+exports.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: ".", "?", "#", "/", "\"
+ */
+exports.DEFAULT_VALIDATION_SCHEMA = {
+    additionalProperties: {
+        oneOf: [
+            {
+                type: 'number',
+            },
+            {
+                type: 'string',
+                pattern: '^((?!(\\.\\.|\\?|#|\\\\|\\/)).)*$',
+            },
+            {
+                type: 'object',
+            },
+        ],
+    },
+};

package/build/index.d.ts

@@ -0,0 +1,11 @@
+import { ApiWithRoot, GatewayConfig, GatewayRequest, GatewayResponse, SchemasByScope } from './models/common';
+import { GatewayContext } from './models/context';
+export * from './utils/typed-api';
+export * from './utils/grpc-reflection';
+export * from './models/common';
+export * from './models/context';
+export * from './models/error';
+export default 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>;
+};