@gravity-ui/gateway 1.0.0

package/build/components/grpc.js

@@ -0,0 +1,664 @@
+"use strict";
+/* eslint-disable camelcase */
+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.getCredentialsMap = exports.createRoot = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const lodash_1 = __importDefault(require("lodash"));
+const object_sizeof_1 = __importDefault(require("object-sizeof"));
+const protobufjs = __importStar(require("protobufjs"));
+const uuid_1 = require("uuid");
+const constants_1 = require("../constants");
+const common_1 = require("../models/common");
+const common_2 = require("../utils/common");
+const grpc_1 = require("../utils/grpc");
+const grpc_reflection_1 = require("../utils/grpc-reflection");
+const parse_error_1 = require("../utils/parse-error");
+const redact_sensitive_headers_1 = require("../utils/redact-sensitive-headers");
+const validate_1 = require("../utils/validate");
+const reflectLoaderOptions = {
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true,
+};
+const grpcLoaderOptions = Object.assign(Object.assign({}, reflectLoaderOptions), { includeDirs: [path_1.default.join(__dirname, '../../proto')] });
+function createRoot(includeGrpcPaths) {
+    const root = new protobufjs.Root();
+    root.loadSync(path_1.default.resolve(__dirname, '../../proto/google/rpc/code.proto'));
+    root.loadSync(path_1.default.resolve(__dirname, '../../proto/google/rpc/error_details.proto'));
+    root.loadSync(path_1.default.resolve(__dirname, '../../proto/google/rpc/status.proto'));
+    // Load well-known internal protobufjs types
+    root.loadSync('google/protobuf/struct.proto');
+    root.loadSync('google/protobuf/wrappers.proto');
+    addIncludePathResolver(root, includeGrpcPaths);
+    return root;
+}
+exports.createRoot = createRoot;
+function addIncludePathResolver(root, includeGrpcPaths) {
+    grpcLoaderOptions.includeDirs = [...grpcLoaderOptions.includeDirs, ...(includeGrpcPaths !== null && includeGrpcPaths !== void 0 ? includeGrpcPaths : [])];
+    const { includeDirs } = grpcLoaderOptions;
+    const originalResolvePath = root.resolvePath;
+    root.resolvePath = function (origin, target) {
+        if (target in protobufjs.common || path_1.default.isAbsolute(target)) {
+            return target;
+        }
+        for (let i = 0; i < includeDirs.length; i++) {
+            const directory = includeDirs[i];
+            const fullPath = path_1.default.join(directory, target);
+            try {
+                fs_1.default.accessSync(fullPath, fs_1.default.constants.R_OK);
+                return fullPath;
+            }
+            catch (err) {
+                continue;
+            }
+        }
+        return originalResolvePath(origin, target);
+    };
+}
+function getCredentialsMap(caCertificatePath) {
+    let certificate;
+    if (caCertificatePath && fs_1.default.existsSync(caCertificatePath)) {
+        certificate = fs_1.default.readFileSync(caCertificatePath);
+    }
+    return {
+        secure: grpc.ChannelCredentials.createSsl(certificate),
+        secureWithoutRootCert: grpc.ChannelCredentials.createSsl(),
+        insecure: grpc.ChannelCredentials.createInsecure(),
+    };
+}
+exports.getCredentialsMap = getCredentialsMap;
+function decodeResponse(response, packageRoot, ctx, encodedFields = [], ErrorConctructor) {
+    const systemFields = ['metadata', 'response', 'error.details'];
+    [...systemFields, ...encodedFields].forEach((fieldName) => {
+        try {
+            const traverseRegExp = /\.\*$/;
+            const needTraverse = traverseRegExp.test(fieldName);
+            const parsedFieldName = needTraverse
+                ? fieldName.replace(traverseRegExp, '')
+                : fieldName;
+            const fieldValue = lodash_1.default.get(response, parsedFieldName);
+            if (fieldValue) {
+                lodash_1.default.set(response, parsedFieldName, needTraverse
+                    ? (0, grpc_1.traverseAnyMessage)(packageRoot, fieldValue)
+                    : (0, grpc_1.decodeAnyMessageRecursively)(packageRoot, fieldValue));
+            }
+        }
+        catch (error) {
+            (0, common_2.handleError)(ErrorConctructor, error, ctx, 'Message decoding failed', { fieldName });
+        }
+    });
+}
+function createMetadata({ options, actionConfig, config, params, serviceName, ctx, }) {
+    var _a;
+    const { headers, requestId, authArgs } = actionConfig;
+    const proxyHeaders = [...constants_1.DEFAULT_PROXY_HEADERS];
+    let metadata = {
+        'x-request-id': requestId,
+        'accept-language': headers[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru,
+    };
+    if (typeof options.proxyHeaders === 'function') {
+        Object.assign(metadata, options.proxyHeaders(Object.assign({}, headers), 'grpc'));
+    }
+    else if (Array.isArray(options.proxyHeaders)) {
+        proxyHeaders.push(...options.proxyHeaders);
+    }
+    if (typeof config.proxyHeaders === 'function') {
+        Object.assign(metadata, config.proxyHeaders(Object.assign({}, headers), 'grpc'));
+    }
+    else if (Array.isArray(config.proxyHeaders)) {
+        proxyHeaders.push(...config.proxyHeaders);
+    }
+    for (const headerName of proxyHeaders) {
+        if (metadata[headerName] === undefined) {
+            metadata[headerName] = headers[headerName];
+        }
+    }
+    const authHeaders = ((_a = config.getAuthHeaders) !== null && _a !== void 0 ? _a : options.getAuthHeaders)({
+        actionType: 'grpc',
+        serviceName,
+        requestHeaders: headers,
+        authArgs,
+    });
+    Object.assign(metadata, authHeaders);
+    if (config.idempotency) {
+        const idempotencyKey = headers['idempotency-key'] || (0, uuid_1.v4)();
+        Object.assign(metadata, { 'idempotency-key': idempotencyKey });
+    }
+    const { headers: actionHeaders = null } = params !== null && params !== void 0 ? params : {};
+    if (actionHeaders) {
+        Object.keys(actionHeaders).forEach((key) => {
+            metadata[key] = actionHeaders[key];
+        });
+    }
+    metadata = lodash_1.default.omitBy(Object.assign(Object.assign({}, ctx.getMetadata()), metadata), lodash_1.default.isUndefined);
+    const serviceMetadata = new grpc.Metadata();
+    Object.keys(metadata).forEach((key) => {
+        if (key) {
+            serviceMetadata.add(key, metadata[key]);
+        }
+    });
+    return serviceMetadata;
+}
+function createActionEndpoint(endpointData) {
+    return (0, common_2.isExtendedActionEndpoint)(endpointData) ? endpointData.path : endpointData;
+}
+const packageObjectsMap = new Map();
+const serviceInstancesMap = {};
+const reflectionServiceInstancesMap = {};
+function clearInstancesCache(service, instancesMap, cachePath, closeTimeout, ctx) {
+    const cachedService = lodash_1.default.get(instancesMap, cachePath);
+    if (cachedService !== service) {
+        return;
+    }
+    // Remove cached service instance
+    lodash_1.default.unset(instancesMap, cachePath);
+    // Try to close service connection (prevent memory leak)
+    // Bug in node >= 18.15.0 https://github.com/grpc/grpc-node/issues/2091
+    // use setTimeout
+    Promise.resolve(cachedService).then((client) => {
+        setTimeout(() => {
+            var _a;
+            try {
+                (_a = client === null || client === void 0 ? void 0 : client.close) === null || _a === void 0 ? void 0 : _a.call(client);
+            }
+            catch (error) {
+                ctx.logError('Failed to close connection during clearing instances cache', error, {
+                    cachePath,
+                });
+            }
+        }, closeTimeout);
+    });
+}
+function getChannelCredential(config, endpointData, credentials) {
+    let endpointInsecure;
+    let endpointSecureWithoutRootCert;
+    if ((0, common_2.isExtendedGrpcActionEndpoint)(endpointData)) {
+        endpointInsecure = endpointData === null || endpointData === void 0 ? void 0 : endpointData.insecure;
+        endpointSecureWithoutRootCert = endpointData === null || endpointData === void 0 ? void 0 : endpointData.secureWithoutRootCert;
+    }
+    const isInsecure = config.insecure || endpointInsecure;
+    const isSecureWithoutRootCert = config.secureWithoutRootCert || endpointSecureWithoutRootCert;
+    let creds = credentials.secure;
+    if (isInsecure) {
+        creds = credentials.insecure;
+    }
+    else if (isSecureWithoutRootCert) {
+        creds = credentials.secureWithoutRootCert;
+    }
+    return creds;
+}
+const reflectionCacheStatusMap = {};
+function needRefreshCache(actionEndpoint, protoKey, reflectionRefreshSec) {
+    const cacheStatus = lodash_1.default.get(reflectionCacheStatusMap, [protoKey, actionEndpoint]);
+    if (!cacheStatus) {
+        lodash_1.default.set(reflectionCacheStatusMap, [protoKey, actionEndpoint], {
+            time: Date.now() / 1000,
+            isRefresh: false,
+        });
+        return false;
+    }
+    if (cacheStatus.isRefresh) {
+        return false;
+    }
+    return cacheStatus.time + reflectionRefreshSec < Date.now() / 1000;
+}
+async function refreshCache(actionEndpoint, config, endpointData, grpcOptions, credentials) {
+    const cacheStatus = lodash_1.default.get(reflectionCacheStatusMap, [config.protoKey, actionEndpoint]);
+    if (!cacheStatus) {
+        return;
+    }
+    lodash_1.default.set(reflectionCacheStatusMap, [config.protoKey, actionEndpoint], Object.assign(Object.assign({}, cacheStatus), { isRefresh: true }));
+    const res = await getServiceInstanceReflect(config, endpointData, grpcOptions, credentials, true);
+    lodash_1.default.set(reflectionServiceInstancesMap, [config.protoKey, actionEndpoint], Promise.resolve(res));
+    lodash_1.default.set(reflectionCacheStatusMap, [config.protoKey, actionEndpoint], {
+        time: Date.now() / 1000,
+        isRefresh: false,
+    });
+}
+function getServiceInstanceReflectCached(config, endpointData, grpcOptions, credentials) {
+    if (config.reflection === common_1.GrpcReflection.OnEveryRequest) {
+        return getServiceInstanceReflect(config, endpointData, grpcOptions, credentials);
+    }
+    const actionEndpoint = createActionEndpoint(endpointData);
+    const cacheKey = [config.protoKey, actionEndpoint];
+    const cachedServiceInstance = lodash_1.default.get(reflectionServiceInstancesMap, cacheKey);
+    if (cachedServiceInstance) {
+        if (config.reflectionRefreshSec &&
+            needRefreshCache(actionEndpoint, config.protoKey, config.reflectionRefreshSec)) {
+            refreshCache(actionEndpoint, config, endpointData, grpcOptions, credentials);
+        }
+        return cachedServiceInstance;
+    }
+    const service = getServiceInstanceReflect(config, endpointData, grpcOptions, credentials);
+    lodash_1.default.set(reflectionServiceInstancesMap, cacheKey, service);
+    return service;
+}
+async function getServiceInstanceReflect(config, endpointData, grpcOptions, credentials, isRefreshCache) {
+    const actionEndpoint = createActionEndpoint(endpointData);
+    const endpointInsecure = (0, common_2.isExtendedGrpcActionEndpoint)(endpointData)
+        ? endpointData === null || endpointData === void 0 ? void 0 : endpointData.insecure
+        : undefined;
+    const isInsecure = config.insecure || endpointInsecure;
+    const creds = isInsecure ? credentials.insecure : credentials.secure;
+    let loadedRoot;
+    if (config.reflection === common_1.GrpcReflection.OnEveryRequest || isRefreshCache) {
+        loadedRoot = await (0, grpc_reflection_1.getReflectionRoot)(actionEndpoint, config.protoKey, creds, isRefreshCache);
+    }
+    else {
+        loadedRoot = await (0, grpc_reflection_1.getCachedReflectionRoot)(actionEndpoint, config.protoKey, creds);
+    }
+    const descriptor = loadedRoot.toDescriptor('proto3');
+    const definition = protoLoader.loadFileDescriptorSetFromObject(descriptor, reflectLoaderOptions);
+    const packageObject = grpc.loadPackageDefinition(definition);
+    const Service = lodash_1.default.get(packageObject, config.protoKey);
+    const endpointGrpcOptions = (0, common_2.isExtendedGrpcActionEndpoint)(endpointData)
+        ? endpointData.grpcOptions || {}
+        : {};
+    const serviceInstance = new Service(actionEndpoint, creds, Object.assign(Object.assign(Object.assign({}, constants_1.DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions));
+    return serviceInstance;
+}
+function loadAndCachePackageObject(root, protoPath) {
+    var _a;
+    const cachedPackageObject = (_a = packageObjectsMap.get(root)) === null || _a === void 0 ? void 0 : _a[protoPath];
+    if (cachedPackageObject) {
+        return cachedPackageObject;
+    }
+    root.loadSync(protoPath);
+    const definition = protoLoader.loadSync(protoPath, grpcLoaderOptions);
+    const packageObject = grpc.loadPackageDefinition(definition);
+    let packageObjectsByRoot = packageObjectsMap.get(root);
+    if (!packageObjectsByRoot) {
+        packageObjectsByRoot = {};
+        packageObjectsMap.set(root, packageObjectsByRoot);
+    }
+    packageObjectsByRoot[protoPath] = packageObject;
+    return packageObject;
+}
+async function getServiceInstance(root, config, endpointData, grpcOptions, credentials) {
+    if ('reflection' in config) {
+        return getServiceInstanceReflectCached(config, endpointData, grpcOptions, credentials);
+    }
+    const actionEndpoint = createActionEndpoint(endpointData);
+    const cacheKey = [config.protoKey, actionEndpoint];
+    let serviceInstance = lodash_1.default.get(serviceInstancesMap, cacheKey);
+    if (!serviceInstance) {
+        const packageObject = loadAndCachePackageObject(root, config.protoPath);
+        const Service = lodash_1.default.get(packageObject, config.protoKey);
+        const creds = getChannelCredential(config, endpointData, credentials);
+        const endpointGrpcOptions = (0, common_2.isExtendedGrpcActionEndpoint)(endpointData)
+            ? endpointData.grpcOptions || {}
+            : {};
+        serviceInstance = new Service(actionEndpoint, creds, Object.assign(Object.assign(Object.assign({}, constants_1.DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions));
+        // Save pointer to service in cache
+        lodash_1.default.set(serviceInstancesMap, cacheKey, serviceInstance);
+    }
+    return serviceInstance;
+}
+async function getResponseData({ config, response, ctx, packageRoot, args, ErrorConctructor, }) {
+    // Handle operation's runtime protocol buffers
+    if (response) {
+        const encodedFields = config.encodedFields;
+        if (Array.isArray(response)) {
+            response.forEach((responseItem) => decodeResponse(responseItem, packageRoot, ctx, encodedFields, ErrorConctructor));
+        }
+        else if (typeof response === 'object') {
+            decodeResponse(response, packageRoot, ctx, encodedFields, ErrorConctructor);
+        }
+    }
+    let responseData = response;
+    if (config.transformResponseData) {
+        try {
+            responseData = await config.transformResponseData(response, {
+                args,
+                ctx,
+            });
+            ctx.log('Transformed response data');
+        }
+        catch (error) {
+            (0, common_2.handleError)(ErrorConctructor, error, ctx, 'Transform response data failed');
+        }
+    }
+    return responseData;
+}
+function createGrpcAction({ root, credentials }, endpoints, config, serviceKey, actionName, options, ErrorConctructor) {
+    const serviceName = (options === null || options === void 0 ? void 0 : options.serviceName) || serviceKey;
+    let getService;
+    let recreateService;
+    let getActionEndpoint;
+    const grpcOptions = (options === null || options === void 0 ? void 0 : options.grpcOptions) || {};
+    if (!('reflection' in config)) {
+        loadAndCachePackageObject(root, config.protoPath);
+    }
+    if (typeof config.endpoint === 'function') {
+        // ToDo: memoize services in cache keys depends on args
+        getActionEndpoint = (args) => {
+            const endpointData = config.endpoint(endpoints, args);
+            return createActionEndpoint(endpointData);
+        };
+        getService = (args) => {
+            const endpointData = config.endpoint(endpoints, args);
+            // Client will be created on first request because it depends on args
+            return getServiceInstance(root, config, endpointData, grpcOptions, credentials);
+        };
+        recreateService = (service, closeTimeout, ctx, args) => {
+            const actionEndpoint = getActionEndpoint(args);
+            const serviceInstancesCache = 'reflection' in config ? reflectionServiceInstancesMap : serviceInstancesMap;
+            const cachePath = [config.protoKey, actionEndpoint];
+            clearInstancesCache(service, serviceInstancesCache, cachePath, closeTimeout, ctx);
+        };
+    }
+    else if (endpoints) {
+        let endpointData = endpoints.grpcEndpoint || endpoints.endpoint;
+        if (config.endpoint) {
+            endpointData = endpoints[config.endpoint];
+        }
+        if (endpointData) {
+            const actionEndpoint = createActionEndpoint(endpointData);
+            if ('reflection' in config &&
+                (config.reflection === common_1.GrpcReflection.OnEveryRequest ||
+                    config.reflection === common_1.GrpcReflection.OnFirstRequest)) {
+                getService = () => getServiceInstanceReflectCached(config, endpointData, grpcOptions, credentials);
+                recreateService = (service, closeTimeout, ctx) => {
+                    const cachePath = [config.protoKey, actionEndpoint];
+                    clearInstancesCache(service, reflectionServiceInstancesMap, cachePath, closeTimeout, ctx);
+                };
+            }
+            else {
+                getService = () => getServiceInstance(root, config, endpointData, grpcOptions, credentials);
+                recreateService = (service, closeTimeout, ctx) => {
+                    const serviceInstancesCache = 'reflection' in config
+                        ? reflectionServiceInstancesMap
+                        : serviceInstancesMap;
+                    const cachePath = [config.protoKey, actionEndpoint];
+                    clearInstancesCache(service, serviceInstancesCache, cachePath, closeTimeout, ctx);
+                };
+            }
+            getActionEndpoint = () => actionEndpoint;
+        }
+    }
+    return async function action(actionConfig) {
+        const { args, requestId, headers, ctx: parentCtx } = actionConfig;
+        const { action } = config;
+        const lang = headers[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru; // header might be empty string
+        const ctx = parentCtx.create(`Gateway ${serviceName} ${actionName} [grpc]`, {
+            tags: {
+                action: actionName,
+                service: serviceName,
+                type: 'grpc',
+            },
+        });
+        const startRequestTime = Date.now();
+        const requestData = {
+            timestamp: startRequestTime,
+            service: serviceName,
+            action: actionName,
+            requestTime: 0,
+            requestId: actionConfig.requestId,
+            requestMethod: action,
+            requestUrl: config.protoKey,
+        };
+        const debugHeaders = {
+            'x-api-request-action': action,
+            'x-api-request-protokey': config.protoKey,
+            'x-api-request-lang': lang,
+            'x-request-id': requestId,
+            'x-gateway-version': constants_1.VERSION,
+        };
+        if ('protoPath' in config) {
+            debugHeaders['x-api-request-protopath'] = config.protoPath;
+        }
+        ctx.log('Initiating request', { debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders) });
+        const sendStats = (status, data) => {
+            if (options === null || options === void 0 ? void 0 : options.sendStats) {
+                options.sendStats(Object.assign(Object.assign({}, data), { restStatus: status }), (0, redact_sensitive_headers_1.redactSensitiveHeaders)(parentCtx, headers), parentCtx, { debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders) });
+            }
+            else {
+                ctx.stats(Object.assign(Object.assign({}, requestData), { responseStatus: status }));
+            }
+        };
+        function processError(grpcError) {
+            var _a;
+            const restStatus = lodash_1.default.get(grpcError.getGatewayError(), 'status', 500);
+            sendStats(restStatus, Object.assign(Object.assign({}, requestData), { responseSize: (_a = grpcError.getRawError()) === null || _a === void 0 ? void 0 : _a.metadata, grpcStatus: grpcError.getGatewayError().code }));
+            ctx.logError('Request failed', ErrorConctructor.wrap(grpcError.getAppError(ErrorConctructor)), Object.assign({ serviceName,
+                actionName, debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders) }, grpcError.getGatewayError()));
+            ctx.end();
+        }
+        let params;
+        if (config.params) {
+            try {
+                params = await config.params(args, headers, { ctx });
+            }
+            catch (error) {
+                (0, common_2.handleError)(ErrorConctructor, error, ctx, 'Getting config params failed');
+            }
+        }
+        let service;
+        try {
+            service = await getService(args);
+        }
+        catch (error) {
+            (0, common_2.handleError)(ErrorConctructor, error, ctx, 'getService failed');
+            throw error;
+        }
+        // eslint-disable-next-line complexity
+        return new Promise((resolve, reject) => {
+            var _a, _b, _c, _d;
+            let endpointData = (endpoints === null || endpoints === void 0 ? void 0 : endpoints.grpcEndpoint) || (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}"`;
+                throw new parse_error_1.GrpcError(errorText, {
+                    status: 400,
+                    code: 'ENDPOINT_NOT_FOUND',
+                    message: errorText,
+                });
+            }
+            const actionEndpoint = getActionEndpoint(args);
+            debugHeaders['x-api-request-endpoint'] = actionEndpoint;
+            const validationSchema = config.validationSchema || options.validationSchema;
+            const invalidParams = validationSchema ? (0, validate_1.validateArgs)(args, validationSchema) : false;
+            if (invalidParams) {
+                throw new parse_error_1.GrpcError('Invalid params', {
+                    status: 400,
+                    code: 'INVALID_PARAMS',
+                    message: 'Validation failed',
+                    details: {
+                        title: 'Invalid params',
+                        description: invalidParams,
+                    },
+                });
+            }
+            const timeout = (_c = (_b = (_a = actionConfig === null || actionConfig === void 0 ? void 0 : actionConfig.timeout) !== null && _a !== void 0 ? _a : config === null || config === void 0 ? void 0 : config.timeout) !== null && _b !== void 0 ? _b : options === null || options === void 0 ? void 0 : options.timeout) !== null && _c !== void 0 ? _c : constants_1.DEFAULT_TIMEOUT;
+            const serviceOptions = {
+                deadline: Date.now() + timeout,
+            };
+            const { body = null } = params !== null && params !== void 0 ? params : { body: args };
+            const serviceMetadata = createMetadata({
+                options,
+                actionConfig,
+                config,
+                params,
+                serviceName,
+                ctx,
+            });
+            if (!service[action]) {
+                reject(new parse_error_1.GrpcError('Not found action', {
+                    status: 400,
+                    code: 'GRPC_ACTION_NOT_FOUND',
+                    message: `Not found action ${action} in ${serviceKey}`,
+                }));
+                return;
+            }
+            switch (config.type) {
+                case 'serverStream': {
+                    ctx.log('Creating serverStream request', {
+                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                    });
+                    const actionCall = service[action].bind(service);
+                    const stream = actionCall(body, serviceMetadata, serviceOptions);
+                    stream.on('error', (error) => {
+                        ctx.log('ServerStream error', {
+                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                        });
+                        processError(new parse_error_1.GrpcError('ClientReadableStream error', (0, parse_error_1.parseGrpcError)(error, root, lang), error));
+                    });
+                    stream.on('status', (status) => {
+                        ctx.log('ServerStream status changed', status);
+                    });
+                    stream.on('end', () => {
+                        ctx.log('ServerStream request completed', {
+                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                        });
+                        ctx.end();
+                    });
+                    resolve({ debugHeaders, stream });
+                    return;
+                }
+                case 'clientStream': {
+                    ctx.log('Creating clientStream request', {
+                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                    });
+                    if (!actionConfig.callback) {
+                        throw new parse_error_1.GrpcError('Invalid action type', {
+                            status: 400,
+                            code: 'ACTION_CALLBACK_REQUIRED',
+                            message: `Client stream actions require callback function`,
+                        });
+                    }
+                    const actionCall = service[action].bind(service);
+                    const stream = actionCall(serviceMetadata, serviceOptions, actionConfig.callback);
+                    resolve({ debugHeaders, stream });
+                    return;
+                }
+                case 'bidi': {
+                    ctx.log('Creating serverStream request', {
+                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                    });
+                    const actionCall = service[action].bind(service);
+                    const stream = actionCall(serviceMetadata, serviceOptions);
+                    stream.on('error', (error) => {
+                        ctx.log('BidiStream error', {
+                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                        });
+                        processError(new parse_error_1.GrpcError('BidiStream error', (0, parse_error_1.parseGrpcError)(error, root, lang), error));
+                    });
+                    stream.on('status', (status) => {
+                        ctx.log('BidiStream status changed', status);
+                    });
+                    stream.on('end', () => {
+                        ctx.log('BidiStream request completed', {
+                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                        });
+                        ctx.end();
+                    });
+                    resolve({
+                        debugHeaders,
+                        stream,
+                    });
+                    return;
+                }
+                default: {
+                    ctx.log('Starting unary request', {
+                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                    });
+                    let retries = (_d = config.retries) !== null && _d !== void 0 ? _d : 0;
+                    let actionCall = service[action].bind(service);
+                    const callAction = () => {
+                        let trailingMetadata = {};
+                        const call = actionCall(body, serviceMetadata, serviceOptions, async (error, response) => {
+                            const endRequestTime = Date.now();
+                            requestData.requestTime = endRequestTime - startRequestTime;
+                            const shouldRecreateService = error &&
+                                options.grpcRecreateService &&
+                                (0, grpc_1.isRecreateServiceError)(error);
+                            const shouldRetry = error && retries && (0, grpc_1.isRetryableError)(error);
+                            if (shouldRecreateService) {
+                                ctx.log(`Service client for ${config.protoKey} is going to be re-created`);
+                                recreateService(service, timeout * 1.5, ctx, args);
+                            }
+                            if (shouldRetry) {
+                                ctx.logError(`Request failed, retrying ${retries--} more times`);
+                                // Update pointer to re-created client in local service variable
+                                try {
+                                    service = await getService(args);
+                                }
+                                catch (error) {
+                                    (0, common_2.handleError)(ErrorConctructor, error, ctx, 'getService failed');
+                                    throw error;
+                                }
+                                // Update service
+                                actionCall = service[action].bind(service);
+                                callAction();
+                                return;
+                            }
+                            if (error) {
+                                reject(new parse_error_1.GrpcError('gRPC request error', (0, parse_error_1.parseGrpcError)(error, root, lang), error));
+                                return;
+                            }
+                            const responseData = await getResponseData({
+                                response,
+                                ctx,
+                                config,
+                                args,
+                                packageRoot: root,
+                                ErrorConctructor,
+                            });
+                            Object.assign(debugHeaders, (0, common_2.getHeadersFromMetadata)(trailingMetadata));
+                            sendStats(200, Object.assign(Object.assign({}, requestData), { responseSize: (0, object_sizeof_1.default)(response), grpcStatus: 0 }));
+                            ctx.log('Request completed', {
+                                debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                            });
+                            ctx.end();
+                            return resolve({ responseData, debugHeaders });
+                        });
+                        call.on('status', (status) => {
+                            trailingMetadata = status.metadata.toJSON();
+                        });
+                    };
+                    callAction();
+                }
+            }
+        }).catch((error) => {
+            const grpcError = (0, parse_error_1.isGrpcError)(error) ? error : (0, parse_error_1.grpcErrorFactory)(error);
+            processError(grpcError);
+            return Promise.reject({ error: grpcError.getGatewayError(), debugHeaders });
+        });
+    };
+}
+exports.default = createGrpcAction;

package/build/components/mixed.d.ts

@@ -0,0 +1,11 @@
+import { ApiActionConfig, ApiByScope, ApiServiceMixedActionConfig, GatewayConfig, GatewayRequest, GatewayResponse, SchemasByScope } from '../models/common';
+import { GatewayContext } from '../models/context';
+import { AppErrorConstructor } from '../models/error';
+import type { GrpcContext } from './grpc';
+export declare function createMixedAction<TSchema extends SchemasByScope, Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse>(config: ApiServiceMixedActionConfig<Context, Req, Res, any, any, any>, api: ApiByScope<TSchema, Context, Req, Res>, serviceName: string, actionName: string, extra: {
+    config: GatewayConfig<Context, Req, Res>;
+    grpcContext: GrpcContext;
+}, ErrorConctructor: AppErrorConstructor): (actionConfig: ApiActionConfig<Context, any>) => Promise<{
+    responseData: any;
+    debugHeaders: {};
+}>;