@gravity-ui/gateway 4.1.2-alpha.0 → 4.2.0

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

@@ -1,24 +0,0 @@
-import * as grpc from '@grpc/grpc-js';
-import * as protobufjs from 'protobufjs';
-import type * as descriptor from 'protobufjs/ext/descriptor';
-import { ApiActionConfig, ApiServiceGrpcActionConfig, EndpointsConfig, GatewayApiOptions } from '../models/common.js';
-import { GatewayContext } from '../models/context.js';
-import { AppErrorConstructor } from '../models/error.js';
-declare module 'protobufjs' {
-    interface Root {
-        toDescriptor(protoVersion: string): protobufjs.Message<descriptor.IFileDescriptorSet> & descriptor.IFileDescriptorSet;
-    }
-}
-interface CredentialsMap {
-    insecure: grpc.ChannelCredentials;
-    secure: grpc.ChannelCredentials;
-    secureWithoutRootCert: grpc.ChannelCredentials;
-}
-export interface GrpcContext {
-    root: protobufjs.Root;
-    credentials: CredentialsMap;
-}
-export declare function createRoot(includeGrpcPaths?: string[]): protobufjs.Root;
-export declare function getCredentialsMap(caCertificatePath?: string | null): CredentialsMap;
-export declare function createGrpcAction<Context extends GatewayContext>({ root, credentials }: GrpcContext, endpoints: EndpointsConfig | undefined, config: ApiServiceGrpcActionConfig<Context, any, any>, serviceKey: string, actionName: string, options: GatewayApiOptions<Context>, ErrorConstructor: AppErrorConstructor): (actionConfig: ApiActionConfig<Context, any, any>) => Promise<import("../models/common.js").GatewayActionClientStreamResponse<any> | import("../models/common.js").GatewayActionServerStreamResponse<any> | import("../models/common.js").GatewayActionDuplexStreamResponse<any> | import("../models/common.js").GatewayActionUnaryResponse<any>>;
-export {};

package/dist/esm/components/grpc.js

@@ -1,641 +0,0 @@
-/* eslint-disable camelcase */
-import fs from 'fs';
-import path from 'path';
-import * as grpc from '@grpc/grpc-js';
-import * as protoLoader from '@grpc/proto-loader';
-import _ from 'lodash';
-import sizeof from 'object-sizeof';
-import * as protobufjs from 'protobufjs';
-import { v4 as uuidv4 } from 'uuid';
-import { DEFAULT_GRPC_OPTIONS, DEFAULT_LANG_HEADER, DEFAULT_PROTO_LOADER_OPTIONS, DEFAULT_PROXY_HEADERS, DEFAULT_TIMEOUT, Lang, VERSION, } from '../constants.js';
-import { GrpcReflection, } from '../models/common.js';
-import { getHeadersFromMetadata, handleError, isExtendedActionEndpoint, isExtendedGrpcActionEndpoint, sanitizeDebugHeaders, } from '../utils/common.js';
-import { getCachedReflectionRoot, getReflectionRoot } from '../utils/grpc-reflection.js';
-import { decodeAnyMessageRecursively, isRecreateServiceError, isRetryableError, } from '../utils/grpc.js';
-import { packageRoot } from '../utils/package-root.js';
-import { GrpcError, grpcErrorFactory, isGrpcError, parseGrpcError } from '../utils/parse-error.js';
-import { patchProtoPathResolver } from '../utils/proto-path-resolver.js';
-import { redactSensitiveHeaders } from '../utils/redact-sensitive-headers.js';
-import { validateArgs } from '../utils/validate.js';
-const grpcLoaderOptions = Object.assign(Object.assign({}, DEFAULT_PROTO_LOADER_OPTIONS), { includeDirs: [path.join(packageRoot, 'proto')] });
-export function createRoot(includeGrpcPaths) {
-    const root = new protobufjs.Root();
-    root.loadSync(path.resolve(packageRoot, 'proto/google/rpc/code.proto'));
-    root.loadSync(path.resolve(packageRoot, 'proto/google/rpc/error_details.proto'));
-    root.loadSync(path.resolve(packageRoot, 'proto/google/rpc/status.proto'));
-    // Load well-known internal protobufjs types
-    root.loadSync('google/protobuf/struct.proto');
-    root.loadSync('google/protobuf/wrappers.proto');
-    grpcLoaderOptions.includeDirs = [...grpcLoaderOptions.includeDirs, ...(includeGrpcPaths !== null && includeGrpcPaths !== void 0 ? includeGrpcPaths : [])];
-    patchProtoPathResolver(root, grpcLoaderOptions.includeDirs);
-    return root;
-}
-export function getCredentialsMap(caCertificatePath) {
-    let certificate;
-    if (caCertificatePath && fs.existsSync(caCertificatePath)) {
-        certificate = fs.readFileSync(caCertificatePath);
-    }
-    return {
-        secure: grpc.ChannelCredentials.createSsl(certificate),
-        secureWithoutRootCert: grpc.ChannelCredentials.createSsl(),
-        insecure: grpc.ChannelCredentials.createInsecure(),
-    };
-}
-function decodeResponse(response, packageRoot, ctx, encodedFields = [], ErrorConstructor, decodeAnyMessageProtoLoaderOptions) {
-    const systemFields = ['metadata', 'response', 'error.details'];
-    [...systemFields, ...encodedFields].forEach((fieldName) => {
-        try {
-            const parsedFieldName = fieldName.replace(/\.\*$/, '');
-            const fieldValue = _.get(response, parsedFieldName);
-            if (fieldValue) {
-                _.set(response, parsedFieldName, decodeAnyMessageRecursively(packageRoot, fieldValue, decodeAnyMessageProtoLoaderOptions));
-            }
-        }
-        catch (error) {
-            handleError(ErrorConstructor, error, ctx, 'Message decoding failed', { fieldName });
-        }
-    });
-}
-function createMetadata({ options, actionConfig, config, params, serviceName, ctx, }) {
-    var _a;
-    const { headers, requestId, authArgs } = actionConfig;
-    const proxyHeaders = [...DEFAULT_PROXY_HEADERS];
-    let metadata = {
-        'x-request-id': requestId,
-        'accept-language': headers[DEFAULT_LANG_HEADER] || 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'] || uuidv4();
-        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 = _.omitBy(Object.assign(Object.assign({}, ctx.getMetadata()), metadata), _.isUndefined);
-    const serviceMetadata = new grpc.Metadata();
-    Object.keys(metadata).forEach((key) => {
-        if (key) {
-            serviceMetadata.add(key, metadata[key]);
-        }
-    });
-    return serviceMetadata;
-}
-function createActionEndpoint(endpointData) {
-    return isExtendedActionEndpoint(endpointData) ? endpointData.path : endpointData;
-}
-const packageObjectsMap = new Map();
-const serviceInstancesMap = {};
-const reflectionServiceInstancesMap = {};
-function clearInstancesCache(service, instancesMap, cachePath, closeTimeout, ctx) {
-    const cachedService = _.get(instancesMap, cachePath);
-    if (cachedService !== service) {
-        return;
-    }
-    // Remove cached service instance
-    _.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 (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 = _.get(reflectionCacheStatusMap, [protoKey, actionEndpoint]);
-    if (!cacheStatus) {
-        _.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 = _.get(reflectionCacheStatusMap, [config.protoKey, actionEndpoint]);
-    if (!cacheStatus) {
-        return;
-    }
-    _.set(reflectionCacheStatusMap, [config.protoKey, actionEndpoint], Object.assign(Object.assign({}, cacheStatus), { isRefresh: true }));
-    try {
-        const res = await getServiceInstanceReflect(config, endpointData, grpcOptions, credentials, true);
-        _.set(reflectionServiceInstancesMap, [config.protoKey, actionEndpoint], Promise.resolve(res));
-        _.set(reflectionCacheStatusMap, [config.protoKey, actionEndpoint], {
-            time: Date.now() / 1000,
-            isRefresh: false,
-        });
-    }
-    catch (e) {
-        _.set(reflectionCacheStatusMap, [config.protoKey, actionEndpoint], Object.assign(Object.assign({}, cacheStatus), { isRefresh: false }));
-    }
-}
-function getServiceInstanceReflectCached(config, endpointData, grpcOptions, credentials) {
-    if (config.reflection === GrpcReflection.OnEveryRequest) {
-        return getServiceInstanceReflect(config, endpointData, grpcOptions, credentials);
-    }
-    const actionEndpoint = createActionEndpoint(endpointData);
-    const cacheKey = [config.protoKey, actionEndpoint];
-    const cachedServiceInstance = _.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);
-    _.set(reflectionServiceInstancesMap, cacheKey, service);
-    service.catch(() => {
-        _.set(reflectionServiceInstancesMap, cacheKey, undefined);
-    });
-    return service;
-}
-async function getServiceInstanceReflect(config, endpointData, grpcOptions, credentials, isRefreshCache) {
-    const actionEndpoint = createActionEndpoint(endpointData);
-    const endpointInsecure = isExtendedGrpcActionEndpoint(endpointData)
-        ? endpointData === null || endpointData === void 0 ? void 0 : endpointData.insecure
-        : undefined;
-    const isInsecure = config.insecure || endpointInsecure;
-    const creds = isInsecure ? credentials.insecure : credentials.secure;
-    const endpointGrpcOptions = isExtendedGrpcActionEndpoint(endpointData)
-        ? endpointData.grpcOptions || {}
-        : {};
-    const combinedGrpcOptions = Object.assign(Object.assign(Object.assign({}, DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions);
-    let loadedRoot;
-    if (config.reflection === GrpcReflection.OnEveryRequest || isRefreshCache) {
-        loadedRoot = await getReflectionRoot(actionEndpoint, config.protoKey, creds, combinedGrpcOptions, isRefreshCache);
-    }
-    else {
-        loadedRoot = await getCachedReflectionRoot(actionEndpoint, config.protoKey, creds, combinedGrpcOptions);
-    }
-    const descriptor = loadedRoot.toDescriptor('proto3');
-    const definition = protoLoader.loadFileDescriptorSetFromObject(descriptor, DEFAULT_PROTO_LOADER_OPTIONS);
-    const packageObject = grpc.loadPackageDefinition(definition);
-    const Service = _.get(packageObject, config.protoKey);
-    const serviceInstance = new Service(actionEndpoint, creds, combinedGrpcOptions);
-    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 = _.get(serviceInstancesMap, cacheKey);
-    if (!serviceInstance) {
-        const packageObject = loadAndCachePackageObject(root, config.protoPath);
-        const Service = _.get(packageObject, config.protoKey);
-        const creds = getChannelCredential(config, endpointData, credentials);
-        const endpointGrpcOptions = isExtendedGrpcActionEndpoint(endpointData)
-            ? endpointData.grpcOptions || {}
-            : {};
-        serviceInstance = new Service(actionEndpoint, creds, Object.assign(Object.assign(Object.assign({}, DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions));
-        // Save pointer to service in cache
-        _.set(serviceInstancesMap, cacheKey, serviceInstance);
-    }
-    return serviceInstance;
-}
-async function getResponseData({ config, response, ctx, packageRoot, args, ErrorConstructor, decodeAnyMessageProtoLoaderOptions, }) {
-    // Handle operation's runtime protocol buffers
-    if (response) {
-        const encodedFields = config.encodedFields;
-        if (Array.isArray(response)) {
-            response.forEach((responseItem) => decodeResponse(responseItem, packageRoot, ctx, encodedFields, ErrorConstructor, decodeAnyMessageProtoLoaderOptions));
-        }
-        else if (typeof response === 'object') {
-            decodeResponse(response, packageRoot, ctx, encodedFields, ErrorConstructor, decodeAnyMessageProtoLoaderOptions);
-        }
-    }
-    let responseData = response;
-    if (config.transformResponseData) {
-        try {
-            responseData = await config.transformResponseData(response, {
-                args,
-                ctx,
-            });
-            ctx.log('Transformed response data');
-        }
-        catch (error) {
-            handleError(ErrorConstructor, error, ctx, 'Transform response data failed');
-        }
-    }
-    return responseData;
-}
-export function createGrpcAction({ root, credentials }, endpoints, config, serviceKey, actionName, options, ErrorConstructor) {
-    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 === GrpcReflection.OnEveryRequest ||
-                    config.reflection === 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) {
-        var _a;
-        const { args, requestId, headers, ctx: parentCtx, userId } = actionConfig;
-        const { action } = config;
-        const lang = headers[DEFAULT_LANG_HEADER] || 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,
-            traceId: ((_a = ctx.getTraceId) === null || _a === void 0 ? void 0 : _a.call(ctx)) || '',
-            userId: userId || '',
-        };
-        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': VERSION,
-        };
-        if ('protoPath' in config) {
-            debugHeaders['x-api-request-protopath'] = config.protoPath;
-        }
-        if (typeof options.proxyDebugHeaders === 'function') {
-            Object.assign(debugHeaders, options.proxyDebugHeaders(Object.assign({}, headers), 'grpc'));
-        }
-        else if (Array.isArray(options.proxyDebugHeaders)) {
-            for (const headerName of options.proxyDebugHeaders) {
-                if (headers[headerName] !== undefined) {
-                    debugHeaders[`x-gateway-${headerName}`] = headers[headerName];
-                }
-            }
-        }
-        ctx.log('Initiating request', { debugHeaders: 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 }), redactSensitiveHeaders(parentCtx, headers), parentCtx, { debugHeaders: sanitizeDebugHeaders(debugHeaders) });
-            }
-            else {
-                ctx.stats(Object.assign(Object.assign({}, requestData), { responseStatus: status }));
-            }
-        };
-        function processError(grpcError) {
-            var _a;
-            const restStatus = _.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', ErrorConstructor.wrap(grpcError.getAppError(ErrorConstructor)), Object.assign({ serviceName,
-                actionName, debugHeaders: sanitizeDebugHeaders(debugHeaders) }, grpcError.getGatewayError()));
-            ctx.end();
-        }
-        let params;
-        if (config.params) {
-            try {
-                params = await config.params(args, headers, { ctx });
-            }
-            catch (error) {
-                handleError(ErrorConstructor, error, ctx, 'Getting config params failed');
-            }
-        }
-        let service;
-        try {
-            service = await getService(args);
-        }
-        catch (error) {
-            handleError(ErrorConstructor, 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 = _.get(endpoints, [config.endpoint]);
-            }
-            if (!endpointData) {
-                const errorText = `Gateway config error. Endpoint has been not found in service "${serviceKey}"`;
-                throw new 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 ? validateArgs(args, validationSchema) : false;
-            if (invalidParams) {
-                throw new 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 : 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 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: sanitizeDebugHeaders(debugHeaders),
-                    });
-                    const actionCall = service[action].bind(service);
-                    const stream = actionCall(body, serviceMetadata, serviceOptions);
-                    stream.on('error', (error) => {
-                        ctx.log('ServerStream error', {
-                            debugHeaders: sanitizeDebugHeaders(debugHeaders),
-                        });
-                        processError(new GrpcError('ClientReadableStream error', parseGrpcError(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
-                    });
-                    stream.on('status', (status) => {
-                        ctx.log('ServerStream status changed', status);
-                    });
-                    stream.on('end', () => {
-                        ctx.log('ServerStream request completed', {
-                            debugHeaders: sanitizeDebugHeaders(debugHeaders),
-                        });
-                        ctx.end();
-                    });
-                    resolve({ debugHeaders, stream });
-                    return;
-                }
-                case 'clientStream': {
-                    ctx.log('Creating clientStream request', {
-                        debugHeaders: sanitizeDebugHeaders(debugHeaders),
-                    });
-                    if (!actionConfig.callback) {
-                        throw new 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: sanitizeDebugHeaders(debugHeaders),
-                    });
-                    const actionCall = service[action].bind(service);
-                    const stream = actionCall(serviceMetadata, serviceOptions);
-                    stream.on('error', (error) => {
-                        ctx.log('BidiStream error', {
-                            debugHeaders: sanitizeDebugHeaders(debugHeaders),
-                        });
-                        processError(new GrpcError('BidiStream error', parseGrpcError(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
-                    });
-                    stream.on('status', (status) => {
-                        ctx.log('BidiStream status changed', status);
-                    });
-                    stream.on('end', () => {
-                        ctx.log('BidiStream request completed', {
-                            debugHeaders: sanitizeDebugHeaders(debugHeaders),
-                        });
-                        ctx.end();
-                    });
-                    resolve({
-                        debugHeaders,
-                        stream,
-                    });
-                    return;
-                }
-                default: {
-                    ctx.log('Starting unary request', {
-                        debugHeaders: 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 &&
-                                isRecreateServiceError(error);
-                            const shouldRetry = error && retries && 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) {
-                                    handleError(ErrorConstructor, error, ctx, 'getService failed');
-                                    throw error;
-                                }
-                                // Update service
-                                actionCall = service[action].bind(service);
-                                callAction();
-                                return;
-                            }
-                            if (error) {
-                                reject(new GrpcError('gRPC request error', parseGrpcError(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
-                                return;
-                            }
-                            const responseData = await getResponseData({
-                                response,
-                                ctx,
-                                config,
-                                args,
-                                packageRoot: root,
-                                ErrorConstructor,
-                                decodeAnyMessageProtoLoaderOptions: config.decodeAnyMessageProtoLoaderOptions,
-                            });
-                            const responseHeaders = {};
-                            if (config.proxyResponseHeaders) {
-                                const proxyResponseHeaders = [];
-                                const headersFromMetadata = getHeadersFromMetadata(trailingMetadata);
-                                if (typeof config.proxyResponseHeaders === 'function') {
-                                    Object.assign(responseHeaders, config.proxyResponseHeaders(headersFromMetadata, 'grpc'));
-                                }
-                                else if (Array.isArray(config.proxyResponseHeaders)) {
-                                    proxyResponseHeaders.push(...config.proxyResponseHeaders);
-                                }
-                                for (const headerName of proxyResponseHeaders) {
-                                    if (responseHeaders[headerName] === undefined) {
-                                        responseHeaders[headerName] =
-                                            headersFromMetadata[headerName];
-                                    }
-                                }
-                            }
-                            Object.assign(debugHeaders, getHeadersFromMetadata(trailingMetadata, 'x-metadata-'));
-                            sendStats(200, Object.assign(Object.assign({}, requestData), { responseSize: sizeof(response), grpcStatus: 0 }));
-                            ctx.log('Request completed', {
-                                debugHeaders: sanitizeDebugHeaders(debugHeaders),
-                            });
-                            ctx.end();
-                            return resolve({ responseData, responseHeaders, debugHeaders });
-                        });
-                        call.on('status', (status) => {
-                            trailingMetadata = status.metadata.toJSON();
-                        });
-                    };
-                    callAction();
-                }
-            }
-        }).catch((error) => {
-            const grpcError = isGrpcError(error) ? error : grpcErrorFactory(error);
-            processError(grpcError);
-            return Promise.reject({ error: grpcError.getGatewayError(), debugHeaders });
-        });
-    };
-}