@gravity-ui/gateway 4.7.1-alpha.0 → 4.7.2

package/{dist/esm → build}/components/grpc.d.ts

@@ -1,9 +1,9 @@
 import * as grpc from '@grpc/grpc-js';
-import protobufjs from 'protobufjs';
+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';
+import { ApiActionConfig, ApiServiceGrpcActionConfig, EndpointsConfig, GatewayApiOptions } from '../models/common';
+import { GatewayContext } from '../models/context';
+import { AppErrorConstructor } from '../models/error';
 declare module 'protobufjs' {
     interface Root {
         toDescriptor(protoVersion: string): protobufjs.Message<descriptor.IFileDescriptorSet> & descriptor.IFileDescriptorSet;
@@ -20,5 +20,5 @@ export interface GrpcContext {
 }
 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 default 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").GatewayActionClientStreamResponse<any> | import("../models/common").GatewayActionServerStreamResponse<any> | import("../models/common").GatewayActionDuplexStreamResponse<any> | import("../models/common").GatewayActionUnaryResponse<any>>;
 export {};

package/{dist/commonjs → build}/components/grpc.js

@@ -16,61 +16,49 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+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.createRoot = createRoot;
-exports.getCredentialsMap = getCredentialsMap;
-exports.createGrpcAction = createGrpcAction;
+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_1 = __importDefault(require("protobufjs"));
+const protobufjs = __importStar(require("protobufjs"));
 const uuid_1 = require("uuid");
-const constants_js_1 = require("../constants.js");
-const common_js_1 = require("../models/common.js");
-const common_js_2 = require("../utils/common.js");
-const grpc_reflection_js_1 = require("../utils/grpc-reflection.js");
-const grpc_js_1 = require("../utils/grpc.js");
-const package_root_js_1 = require("../utils/package-root.js");
-const parse_error_js_1 = require("../utils/parse-error.js");
-const proto_path_resolver_js_1 = require("../utils/proto-path-resolver.js");
-const redact_sensitive_headers_js_1 = require("../utils/redact-sensitive-headers.js");
-const validate_js_1 = require("../utils/validate.js");
-const grpcLoaderOptions = Object.assign(Object.assign({}, constants_js_1.DEFAULT_PROTO_LOADER_OPTIONS), { includeDirs: [path_1.default.join(package_root_js_1.packageRoot, 'proto')] });
+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 proto_path_resolver_1 = require("../utils/proto-path-resolver");
+const redact_sensitive_headers_1 = require("../utils/redact-sensitive-headers");
+const validate_1 = require("../utils/validate");
+const grpcLoaderOptions = Object.assign(Object.assign({}, constants_1.DEFAULT_PROTO_LOADER_OPTIONS), { includeDirs: [path_1.default.join(__dirname, '../../proto')] });
 function createRoot(includeGrpcPaths) {
-    const root = new protobufjs_1.default.Root();
-    root.loadSync(path_1.default.resolve(package_root_js_1.packageRoot, 'proto/google/rpc/code.proto'));
-    root.loadSync(path_1.default.resolve(package_root_js_1.packageRoot, 'proto/google/rpc/error_details.proto'));
-    root.loadSync(path_1.default.resolve(package_root_js_1.packageRoot, 'proto/google/rpc/status.proto'));
+    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');
     grpcLoaderOptions.includeDirs = [...grpcLoaderOptions.includeDirs, ...(includeGrpcPaths !== null && includeGrpcPaths !== void 0 ? includeGrpcPaths : [])];
-    (0, proto_path_resolver_js_1.patchProtoPathResolver)(root, grpcLoaderOptions.includeDirs);
+    (0, proto_path_resolver_1.patchProtoPathResolver)(root, grpcLoaderOptions.includeDirs);
     return root;
 }
+exports.createRoot = createRoot;
 function getCredentialsMap(caCertificatePath) {
     let certificate;
     if (caCertificatePath && fs_1.default.existsSync(caCertificatePath)) {
@@ -82,6 +70,7 @@ function getCredentialsMap(caCertificatePath) {
         insecure: grpc.ChannelCredentials.createInsecure(),
     };
 }
+exports.getCredentialsMap = getCredentialsMap;
 function decodeResponse(response, packageRoot, ctx, encodedFields = [], ErrorConstructor, decodeAnyMessageProtoLoaderOptions) {
     const systemFields = ['metadata', 'response', 'error.details'];
     [...systemFields, ...encodedFields].forEach((fieldName) => {
@@ -89,21 +78,21 @@ function decodeResponse(response, packageRoot, ctx, encodedFields = [], ErrorCon
             const parsedFieldName = fieldName.replace(/\.\*$/, '');
             const fieldValue = lodash_1.default.get(response, parsedFieldName);
             if (fieldValue) {
-                lodash_1.default.set(response, parsedFieldName, (0, grpc_js_1.decodeAnyMessageRecursively)(packageRoot, fieldValue, decodeAnyMessageProtoLoaderOptions));
+                lodash_1.default.set(response, parsedFieldName, (0, grpc_1.decodeAnyMessageRecursively)(packageRoot, fieldValue, decodeAnyMessageProtoLoaderOptions));
             }
         }
         catch (error) {
-            (0, common_js_2.handleError)(ErrorConstructor, error, ctx, 'Message decoding failed', { fieldName });
+            (0, common_2.handleError)(ErrorConstructor, error, ctx, 'Message decoding failed', { fieldName });
         }
     });
 }
 function createMetadata({ options, actionConfig, config, params, serviceName, proxyHeadersCaller, ctx, }) {
     var _a;
     const { headers, requestId, authArgs } = actionConfig;
-    const proxyHeaders = [...constants_js_1.DEFAULT_PROXY_HEADERS];
+    const proxyHeaders = [...constants_1.DEFAULT_PROXY_HEADERS];
     let metadata = {
         'x-request-id': requestId,
-        'accept-language': headers[constants_js_1.DEFAULT_LANG_HEADER] || constants_js_1.Lang.Ru,
+        'accept-language': headers[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru,
     };
     if (typeof options.proxyHeaders === 'function') {
         Object.assign(metadata, proxyHeadersCaller(options.proxyHeaders));
@@ -149,7 +138,7 @@ function createMetadata({ options, actionConfig, config, params, serviceName, pr
     return serviceMetadata;
 }
 function createActionEndpoint(endpointData) {
-    return (0, common_js_2.isExtendedActionEndpoint)(endpointData) ? endpointData.path : endpointData;
+    return (0, common_2.isExtendedActionEndpoint)(endpointData) ? endpointData.path : endpointData;
 }
 const packageObjectsMap = new Map();
 const serviceInstancesMap = {};
@@ -181,7 +170,7 @@ function clearInstancesCache(service, instancesMap, cachePath, closeTimeout, ctx
 function getChannelCredential(config, endpointData, credentials) {
     let endpointInsecure;
     let endpointSecureWithoutRootCert;
-    if ((0, common_js_2.isExtendedGrpcActionEndpoint)(endpointData)) {
+    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;
     }
@@ -230,7 +219,7 @@ async function refreshCache(actionEndpoint, config, endpointData, grpcOptions, c
     }
 }
 function getServiceInstanceReflectCached(config, endpointData, grpcOptions, credentials) {
-    if (config.reflection === common_js_1.GrpcReflection.OnEveryRequest) {
+    if (config.reflection === common_1.GrpcReflection.OnEveryRequest) {
         return getServiceInstanceReflect(config, endpointData, grpcOptions, credentials);
     }
     const actionEndpoint = createActionEndpoint(endpointData);
@@ -252,24 +241,24 @@ function getServiceInstanceReflectCached(config, endpointData, grpcOptions, cred
 }
 async function getServiceInstanceReflect(config, endpointData, grpcOptions, credentials, isRefreshCache) {
     const actionEndpoint = createActionEndpoint(endpointData);
-    const endpointInsecure = (0, common_js_2.isExtendedGrpcActionEndpoint)(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;
-    const endpointGrpcOptions = (0, common_js_2.isExtendedGrpcActionEndpoint)(endpointData)
+    const endpointGrpcOptions = (0, common_2.isExtendedGrpcActionEndpoint)(endpointData)
         ? endpointData.grpcOptions || {}
         : {};
-    const combinedGrpcOptions = Object.assign(Object.assign(Object.assign({}, constants_js_1.DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions);
+    const combinedGrpcOptions = Object.assign(Object.assign(Object.assign({}, constants_1.DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions);
     let loadedRoot;
-    if (config.reflection === common_js_1.GrpcReflection.OnEveryRequest || isRefreshCache) {
-        loadedRoot = await (0, grpc_reflection_js_1.getReflectionRoot)(actionEndpoint, config.protoKey, creds, combinedGrpcOptions, isRefreshCache);
+    if (config.reflection === common_1.GrpcReflection.OnEveryRequest || isRefreshCache) {
+        loadedRoot = await (0, grpc_reflection_1.getReflectionRoot)(actionEndpoint, config.protoKey, creds, combinedGrpcOptions, isRefreshCache);
     }
     else {
-        loadedRoot = await (0, grpc_reflection_js_1.getCachedReflectionRoot)(actionEndpoint, config.protoKey, creds, combinedGrpcOptions);
+        loadedRoot = await (0, grpc_reflection_1.getCachedReflectionRoot)(actionEndpoint, config.protoKey, creds, combinedGrpcOptions);
     }
     const descriptor = loadedRoot.toDescriptor('proto3');
-    const definition = protoLoader.loadFileDescriptorSetFromObject(descriptor, constants_js_1.DEFAULT_PROTO_LOADER_OPTIONS);
+    const definition = protoLoader.loadFileDescriptorSetFromObject(descriptor, constants_1.DEFAULT_PROTO_LOADER_OPTIONS);
     const packageObject = grpc.loadPackageDefinition(definition);
     const Service = lodash_1.default.get(packageObject, config.protoKey);
     const serviceInstance = new Service(actionEndpoint, creds, combinedGrpcOptions);
@@ -303,10 +292,10 @@ async function getServiceInstance(root, config, endpointData, grpcOptions, crede
         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_js_2.isExtendedGrpcActionEndpoint)(endpointData)
+        const endpointGrpcOptions = (0, common_2.isExtendedGrpcActionEndpoint)(endpointData)
             ? endpointData.grpcOptions || {}
             : {};
-        serviceInstance = new Service(actionEndpoint, creds, Object.assign(Object.assign(Object.assign({}, constants_js_1.DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions));
+        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);
     }
@@ -333,11 +322,17 @@ async function getResponseData({ config, response, ctx, packageRoot, args, Error
             ctx.log('Transformed response data');
         }
         catch (error) {
-            (0, common_js_2.handleError)(ErrorConstructor, error, ctx, 'Transform response data failed');
+            (0, common_2.handleError)(ErrorConstructor, error, ctx, 'Transform response data failed');
         }
     }
     return responseData;
 }
+// Function to generate fresh serviceOptions with updated deadline for each attempt
+function createServiceOptions(timeout) {
+    return {
+        deadline: Date.now() + timeout,
+    };
+}
 function createGrpcAction({ root, credentials }, endpoints, config, serviceKey, actionName, options, ErrorConstructor) {
     const serviceName = (options === null || options === void 0 ? void 0 : options.serviceName) || serviceKey;
     let getService;
@@ -373,8 +368,8 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
         if (endpointData) {
             const actionEndpoint = createActionEndpoint(endpointData);
             if ('reflection' in config &&
-                (config.reflection === common_js_1.GrpcReflection.OnEveryRequest ||
-                    config.reflection === common_js_1.GrpcReflection.OnFirstRequest)) {
+                (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];
@@ -398,7 +393,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
         var _a;
         const { args, requestId, headers, ctx: parentCtx, userId, abortSignal } = actionConfig;
         const { action } = config;
-        const lang = headers[constants_js_1.DEFAULT_LANG_HEADER] || constants_js_1.Lang.Ru; // header might be empty string
+        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,
@@ -423,7 +418,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             'x-api-request-protokey': config.protoKey,
             'x-api-request-lang': lang,
             'x-request-id': requestId,
-            'x-gateway-version': constants_js_1.VERSION,
+            'x-gateway-version': constants_1.VERSION,
         };
         const protopath = 'protoPath' in config ? config.protoPath : undefined;
         if (protopath) {
@@ -432,7 +427,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
         let proxyHeadersExtra;
         const proxyHeadersCaller = (proxyHeadersFunc) => {
             if (proxyHeadersExtra === undefined) {
-                proxyHeadersExtra = (0, common_js_2.getProxyHeadersArgs)(serviceName, actionName, config);
+                proxyHeadersExtra = (0, common_2.getProxyHeadersArgs)(serviceName, actionName, config);
             }
             return proxyHeadersFunc(Object.assign({}, headers), 'rest', proxyHeadersExtra);
         };
@@ -446,10 +441,10 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 }
             }
         }
-        ctx.log('Initiating request', { debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders) });
+        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_js_1.redactSensitiveHeaders)(parentCtx, headers), parentCtx, { debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders) });
+                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 }));
@@ -460,7 +455,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             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', ErrorConstructor.wrap(grpcError.getAppError(ErrorConstructor)), Object.assign({ serviceName,
-                actionName, debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders) }, grpcError.getGatewayError()));
+                actionName, debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders) }, grpcError.getGatewayError()));
             ctx.end();
         }
         let params;
@@ -469,7 +464,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 params = await config.params(args, headers, { ctx });
             }
             catch (error) {
-                (0, common_js_2.handleError)(ErrorConstructor, error, ctx, 'Getting config params failed');
+                (0, common_2.handleError)(ErrorConstructor, error, ctx, 'Getting config params failed');
             }
         }
         let service;
@@ -477,7 +472,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             service = await getService(args);
         }
         catch (error) {
-            (0, common_js_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
+            (0, common_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
             throw error;
         }
         let stopListeningForAbort = null;
@@ -493,7 +488,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             }
             if (!endpointData) {
                 const errorText = `Gateway config error. Endpoint has been not found in service "${serviceKey}"`;
-                throw new parse_error_js_1.GrpcError(errorText, {
+                throw new parse_error_1.GrpcError(errorText, {
                     status: 400,
                     code: 'ENDPOINT_NOT_FOUND',
                     message: errorText,
@@ -502,9 +497,9 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             const actionEndpoint = getActionEndpoint(args);
             debugHeaders['x-api-request-endpoint'] = actionEndpoint;
             const validationSchema = config.validationSchema || options.validationSchema;
-            const invalidParams = validationSchema ? (0, validate_js_1.validateArgs)(args, validationSchema) : false;
+            const invalidParams = validationSchema ? (0, validate_1.validateArgs)(args, validationSchema) : false;
             if (invalidParams) {
-                throw new parse_error_js_1.GrpcError('Invalid params', {
+                throw new parse_error_1.GrpcError('Invalid params', {
                     status: 400,
                     code: 'INVALID_PARAMS',
                     message: 'Validation failed',
@@ -514,10 +509,8 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                     },
                 });
             }
-            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_js_1.DEFAULT_TIMEOUT;
-            const serviceOptions = {
-                deadline: Date.now() + timeout,
-            };
+            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;
+            let serviceOptions = createServiceOptions(timeout);
             const { body = null } = params !== null && params !== void 0 ? params : { body: args };
             const serviceMetadata = createMetadata({
                 options,
@@ -529,7 +522,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 ctx,
             });
             if (!service[action]) {
-                reject(new parse_error_js_1.GrpcError('Not found action', {
+                reject(new parse_error_1.GrpcError('Not found action', {
                     status: 400,
                     code: 'GRPC_ACTION_NOT_FOUND',
                     message: `Not found action ${action} in ${serviceKey}`,
@@ -539,11 +532,11 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             switch (config.type) {
                 case 'serverStream': {
                     ctx.log('Creating serverStream request', {
-                        debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
+                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                     });
                     const actionCall = service[action].bind(service);
                     const stream = actionCall(body, serviceMetadata, serviceOptions);
-                    stopListeningForAbort = (0, grpc_js_1.listenForAbort)({
+                    stopListeningForAbort = (0, grpc_1.listenForAbort)({
                         signal: abortSignal,
                         config,
                         call: stream,
@@ -551,9 +544,9 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                     });
                     stream.on('error', (error) => {
                         ctx.log('ServerStream error', {
-                            debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
+                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                         });
-                        processError(new parse_error_js_1.GrpcError('ClientReadableStream error', (0, parse_error_js_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
+                        processError(new parse_error_1.GrpcError('ClientReadableStream error', (0, parse_error_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
                     });
                     stream.on('status', (status) => {
                         ctx.log('ServerStream status changed', status);
@@ -561,7 +554,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                     stream.on('end', () => {
                         stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
                         ctx.log('ServerStream request completed', {
-                            debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
+                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                         });
                         ctx.end();
                     });
@@ -570,10 +563,10 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 }
                 case 'clientStream': {
                     ctx.log('Creating clientStream request', {
-                        debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
+                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                     });
                     if (!actionConfig.callback) {
-                        throw new parse_error_js_1.GrpcError('Invalid action type', {
+                        throw new parse_error_1.GrpcError('Invalid action type', {
                             status: 400,
                             code: 'ACTION_CALLBACK_REQUIRED',
                             message: `Client stream actions require callback function`,
@@ -581,7 +574,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                     }
                     const actionCall = service[action].bind(service);
                     const stream = actionCall(serviceMetadata, serviceOptions, actionConfig.callback);
-                    stopListeningForAbort = (0, grpc_js_1.listenForAbort)({
+                    stopListeningForAbort = (0, grpc_1.listenForAbort)({
                         signal: abortSignal,
                         config,
                         call: stream,
@@ -595,11 +588,11 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 }
                 case 'bidi': {
                     ctx.log('Creating serverStream request', {
-                        debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
+                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                     });
                     const actionCall = service[action].bind(service);
                     const stream = actionCall(serviceMetadata, serviceOptions);
-                    stopListeningForAbort = (0, grpc_js_1.listenForAbort)({
+                    stopListeningForAbort = (0, grpc_1.listenForAbort)({
                         signal: abortSignal,
                         config,
                         call: stream,
@@ -607,9 +600,9 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                     });
                     stream.on('error', (error) => {
                         ctx.log('BidiStream error', {
-                            debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
+                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                         });
-                        processError(new parse_error_js_1.GrpcError('BidiStream error', (0, parse_error_js_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
+                        processError(new parse_error_1.GrpcError('BidiStream error', (0, parse_error_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
                     });
                     stream.on('status', (status) => {
                         ctx.log('BidiStream status changed', status);
@@ -617,7 +610,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                     stream.on('end', () => {
                         stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
                         ctx.log('BidiStream request completed', {
-                            debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
+                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                         });
                         ctx.end();
                     });
@@ -629,7 +622,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 }
                 default: {
                     ctx.log('Starting unary request', {
-                        debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
+                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                     });
                     let retries = (_d = config.retries) !== null && _d !== void 0 ? _d : 0;
                     let actionCall = service[action].bind(service);
@@ -641,37 +634,39 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                             requestData.requestTime = endRequestTime - startRequestTime;
                             const shouldRecreateService = error &&
                                 options.grpcRecreateService &&
-                                (0, grpc_js_1.isRecreateServiceError)(error);
+                                (0, grpc_1.isRecreateServiceError)(error);
                             const shouldRetry = error &&
                                 retries &&
-                                ((_b = (_a = options.grpcRetryCondition) === null || _a === void 0 ? void 0 : _a.call(options, error)) !== null && _b !== void 0 ? _b : (0, grpc_js_1.isRetryableGrpcError)(error));
+                                ((_b = (_a = options.grpcRetryCondition) === null || _a === void 0 ? void 0 : _a.call(options, error)) !== null && _b !== void 0 ? _b : (0, grpc_1.isRetryableGrpcError)(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) {
-                                (0, common_js_2.handleError)(ErrorConstructor, error, ctx, `Request failed, retrying ${retries--} more times`, {
+                                (0, common_2.handleError)(ErrorConstructor, error, ctx, `Request failed, retrying ${retries--} more times`, {
                                     serviceName,
                                     actionName,
-                                    debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
+                                    debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                                 });
                                 // Update pointer to re-created client in local service variable
                                 try {
                                     service = await getService(args);
                                 }
                                 catch (error) {
-                                    (0, common_js_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
+                                    (0, common_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
                                     throw error;
                                 }
                                 stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
                                 // Update service
                                 actionCall = service[action].bind(service);
+                                // Update serviceOptions with a fresh deadline for the retry
+                                serviceOptions = createServiceOptions(timeout);
                                 callAction();
                                 return;
                             }
                             if (error) {
                                 stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
-                                reject(new parse_error_js_1.GrpcError('gRPC request error', (0, parse_error_js_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
+                                reject(new parse_error_1.GrpcError('gRPC request error', (0, parse_error_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
                                 return;
                             }
                             const responseData = await getResponseData({
@@ -686,7 +681,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                             const responseHeaders = {};
                             if (config.proxyResponseHeaders) {
                                 const proxyResponseHeaders = [];
-                                const headersFromMetadata = (0, common_js_2.getHeadersFromMetadata)(trailingMetadata);
+                                const headersFromMetadata = (0, common_2.getHeadersFromMetadata)(trailingMetadata);
                                 if (typeof config.proxyResponseHeaders === 'function') {
                                     Object.assign(responseHeaders, config.proxyResponseHeaders(headersFromMetadata, 'grpc'));
                                 }
@@ -700,10 +695,10 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                                     }
                                 }
                             }
-                            Object.assign(debugHeaders, (0, common_js_2.getHeadersFromMetadata)(trailingMetadata, 'x-metadata-'));
+                            Object.assign(debugHeaders, (0, common_2.getHeadersFromMetadata)(trailingMetadata, 'x-metadata-'));
                             sendStats(200, Object.assign(Object.assign({}, requestData), { responseSize: (0, object_sizeof_1.default)(response), grpcStatus: 0 }));
                             ctx.log('Request completed', {
-                                debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
+                                debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                             });
                             ctx.end();
                             stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
@@ -712,7 +707,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                         call.on('status', (status) => {
                             trailingMetadata = status.metadata.toJSON();
                         });
-                        stopListeningForAbort = (0, grpc_js_1.listenForAbort)({
+                        stopListeningForAbort = (0, grpc_1.listenForAbort)({
                             signal: abortSignal,
                             config,
                             call,
@@ -723,10 +718,11 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 }
             }
         }).catch((error) => {
-            const grpcError = (0, parse_error_js_1.isGrpcError)(error) ? error : (0, parse_error_js_1.grpcErrorFactory)(error);
+            const grpcError = (0, parse_error_1.isGrpcError)(error) ? error : (0, parse_error_1.grpcErrorFactory)(error);
             processError(grpcError);
             stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
             return Promise.reject({ error: grpcError.getGatewayError(), debugHeaders });
         });
     };
 }
+exports.default = createGrpcAction;

package/{dist/esm → build}/components/mixed.d.ts

@@ -1,7 +1,7 @@
-import { ApiActionConfig, ApiByScope, ApiServiceMixedActionConfig, GatewayConfig, GatewayRequest, GatewayResponse, SchemasByScope } from '../models/common.js';
-import { GatewayContext } from '../models/context.js';
-import { AppErrorConstructor } from '../models/error.js';
-import type { GrpcContext } from './grpc.js';
+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;

package/{dist/commonjs → build}/components/mixed.js

@@ -11,11 +11,11 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMixedAction = createMixedAction;
-const constants_js_1 = require("../constants.js");
-const common_js_1 = require("../utils/common.js");
-const create_context_api_js_1 = require("../utils/create-context-api.js");
-const parse_error_js_1 = require("../utils/parse-error.js");
+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, ErrorConstructor) {
     return async (actionConfig) => {
         const { args } = actionConfig, context = __rest(actionConfig, ["args"]);
@@ -26,9 +26,9 @@ function createMixedAction(config, api, serviceName, actionName, extra, ErrorCon
                 type: 'mixed',
             },
         });
-        const contextApi = (0, create_context_api_js_1.generateContextApi)(api, Object.assign(Object.assign({}, context), { ctx }));
+        const contextApi = (0, create_context_api_1.generateContextApi)(api, Object.assign(Object.assign({}, context), { ctx }));
         try {
-            const responseData = await config(contextApi, args, Object.assign(Object.assign({ headers: actionConfig.headers, lang: actionConfig.headers[constants_js_1.DEFAULT_LANG_HEADER] || constants_js_1.Lang.Ru, ctx }, extra), { abortSignal: actionConfig.abortSignal }));
+            const responseData = await config(contextApi, args, Object.assign(Object.assign({ headers: actionConfig.headers, lang: actionConfig.headers[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru, ctx }, extra), { abortSignal: actionConfig.abortSignal }));
             ctx.log('Request completed');
             return {
                 responseData,
@@ -37,15 +37,15 @@ function createMixedAction(config, api, serviceName, actionName, extra, ErrorCon
         }
         catch (e) {
             if (e instanceof Object && 'error' in e) {
-                (0, common_js_1.handleError)(ErrorConstructor, e, ctx, 'Request failed', {
+                (0, common_1.handleError)(ErrorConstructor, e, ctx, 'Request failed', {
                     actionName,
                     serviceName,
                 });
                 throw e;
             }
             if (e instanceof Error) {
-                const parsedError = (0, parse_error_js_1.parseMixedError)(e);
-                (0, common_js_1.handleError)(ErrorConstructor, e, ctx, 'Request failed', {
+                const parsedError = (0, parse_error_1.parseMixedError)(e);
+                (0, common_1.handleError)(ErrorConstructor, e, ctx, 'Request failed', {
                     actionName,
                     serviceName,
                 });
@@ -53,7 +53,7 @@ function createMixedAction(config, api, serviceName, actionName, extra, ErrorCon
                     error: parsedError,
                 };
             }
-            (0, common_js_1.handleError)(ErrorConstructor, e, ctx, 'Request failed');
+            (0, common_1.handleError)(ErrorConstructor, e, ctx, 'Request failed');
             throw {
                 error: e,
             };
@@ -63,3 +63,4 @@ function createMixedAction(config, api, serviceName, actionName, extra, ErrorCon
         }
     };
 }
+exports.createMixedAction = createMixedAction;

package/{dist/commonjs → build}/components/rest.d.ts

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