@gravity-ui/gateway 4.3.0 → 4.4.0

package/README.md

@@ -1,16 +1,35 @@
 # @gravity-ui/gateway · [![npm package](https://img.shields.io/npm/v/@gravity-ui/gateway)](https://www.npmjs.com/package/@gravity-ui/gateway) [![CI](https://img.shields.io/github/actions/workflow/status/gravity-ui/gateway/.github/workflows/ci.yml?label=CI&logo=github)](https://github.com/gravity-ui/gateway/actions/workflows/ci.yml?query=branch:main)
 
-Express controller for working with REST/GRPC APIs.
-
-## Install
+A flexible and powerful Express controller for working with REST and gRPC APIs in Node.js applications.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Basic Usage](#basic-usage)
+- [Configuration](#configuration)
+  - [Config Structure](#config-structure)
+  - [Validation Schema](#validation-schema)
+  - [Using the API in Node.js](#using-the-api-in-nodejs)
+  - [Schema Scopes](#schema-scopes)
+  - [Connecting Specific Actions](#connecting-specific-actions)
+  - [Overriding Endpoints](#overriding-endpoints)
+  - [Authentication](#authentication)
+  - [Error Handling](#error-handling)
+  - [gRPC Reflection](#grpc-reflection-for-grpc-actions)
+  - [Retryable Errors](#retryable-errors)
+- [Development](#development)
+  - [Running Tests](#running-tests)
+  - [Contributing](#contributing)
+
+## Installation
 
 ```shell
-npm install --save-dev @gravity-ui/gateway
+npm install --save @gravity-ui/gateway
 ```
 
-## Usage
+## Basic Usage
 
-First of all, you need to create a controller where you will import Gateway and Schema, and then return the initialized gateway controller:
+First, create a controller by importing Gateway and your API schemas:
 
 ```javascript
 import {getGatewayControllers} from '@gravity-ui/gateway';
@@ -27,7 +46,7 @@ const {controller: gatewayController} = getGatewayControllers({root: Schema}, co
 export default gatewayController;
 ```
 
-Next, the controller described above should be connected to a route of the following format (the project should use [expresskit](https://github.com/gravity-ui/expresskit)):
+Then, connect the controller to your Express routes (using [expresskit](https://github.com/gravity-ui/expresskit)):
 
 ```javascript
 {
@@ -37,11 +56,12 @@ Next, the controller described above should be connected to a route of the follo
 
 The `prefix` can be any prefix for API endpoints (for example, `/gateway/:service/:action`).
 
-### Config Structure
+## Configuration
 
 ```typescript
 import {AxiosRequestConfig} from 'axios';
 import {IncomingHttpHeaders} from 'http';
+import {IAxiosRetryConfig} from 'axios-retry';
 
 interface OnUnknownActionData {
   service?: string;
@@ -67,6 +87,11 @@ type SendStats = (
   meta: {debugHeaders: Headers},
 ) => void;
 
+type GrpcRetryCondition = (error: ServiceError) => boolean;
+type AxiosRetryCondition = IAxiosRetryConfig['retryCondition'];
+
+type ControllerType = 'rest' | 'grpc';
+
 type ProxyHeadersFunction = (
   headers: IncomingHttpHeaders,
   type: ControllerType,
@@ -74,19 +99,48 @@ type ProxyHeadersFunction = (
 type ProxyHeaders = string[] | ProxyHeadersFunction;
 type ResponseContentType = AxiosResponse['headers']['Content-Type'];
 
+type GetAuthHeadersParams<AuthArgs = Record<string, unknown>> = {
+  actionType: ControllerType;
+  serviceName: string;
+  requestHeaders: Headers;
+  authArgs: AuthArgs | undefined;
+};
+
+interface AppErrorArgs {
+  code?: string | number;
+  details?: object;
+  debug?: object;
+}
+
+interface AppErrorWrapArgs extends AppErrorArgs {
+  message?: string;
+}
+
+interface AppErrorConstructor {
+  new (message?: string, args?: AppErrorArgs): Error;
+
+  wrap: (error: Error, args?: AppErrorWrapArgs) => Error;
+}
+
 interface GatewayConfig {
-  // Gateway Installation (external/internal/...). If the configuration is not provided, it is determined from process.env.APP_INSTALLATION.
+  // Gateway Installation (external/internal/...). If not provided, determined from process.env.APP_INSTALLATION.
   installation?: string;
-  // Gateway Environment (production/testing/...). If the configuration is not provided, it is determined from process.env.APP_ENV.
+
+  // Gateway Environment (production/testing/...). If not provided, determined from process.env.APP_ENV.
   env?: string;
+
   // Additional gRPC client options.
   grpcOptions?: object;
+
   // Additional Axios client options.
   axiosConfig?: AxiosRequestConfig;
-  // List of actions that need to be connected from the schema. By default, all actions are connected.
+
+  // List of actions to connect from the schema. By default, all actions are connected.
   actions?: string[];
+
   // Called when an unknown service or action is provided.
   onUnknownAction?: (req: Request, res: Response, data: OnUnknownActionData) => any;
+
   // Called before the request is executed.
   onBeforeAction?: (
     req: Request,
@@ -96,42 +150,90 @@ interface GatewayConfig {
     action: string,
     config?: ApiServiceActionConfig,
   ) => any;
+
   // Called upon successful completion of the request.
   onRequestSuccess?: (req: Request, res: Response, data: any) => any;
+
   // Called in case of unsuccessful request execution.
   onRequestFailed?: (req: Request, res: Response, error: any) => any;
+
   // List of paths to the necessary proto files for the gateway.
   includeProtoRoots?: string[];
+
   // Configuration of the path to the certificate in gRPC.
   // Set to null to use system certificates by default.
   caCertificatePath?: string | null;
+
   // Telemetry sending configuration.
   sendStats?: SendStats;
+
   // Configuration of headers sent to the API.
   proxyHeaders?: ProxyHeaders;
+
   // When passing a boolean value, it enables/disables debug headers in the response to the request.
   // For unary requests to gRPC backends, debug headers will include information from the trailing metadata returned by the backend.
   withDebugHeaders?: boolean;
-  // Validation schema for parameters used when no schema is present in the action. Documentation: https://ajv.js.org/json-schema.html#json-data-type
+
+  // Validation schema for parameters used when no schema is present in the action.
   // You can use DEFAULT_VALIDATION_SCHEMA from lib/constants.ts.
   validationSchema?: object;
+
   // Enables encoding of REST path arguments (default is true).
   encodePathArgs?: boolean;
+
   // Configuration for automatic connection re-establishment upon connection error through L3 load balancer (default is true).
   grpcRecreateService?: boolean;
-  // Enable verification of response contentType header. Actual only for REST actions. This value can be set / redefined the in action confg.
+
+  // Customize retry behavior for grpc requests
+  grpcRetryCondition?: GrpcRetryCondition;
+
+  // Customize retry behavior for rest (axios) requests
+  axiosRetryCondition?: AxiosRetryCondition;
+
+  // Enable verification of response contentType header. Actual only for REST actions.
+  // This value can be set/redefined in the action config.
   expectedResponseContentType?: ResponseContentType | ResponseContentType[];
+
+  // Function to get authentication arguments for API requests
+  getAuthArgs: (req: Request, res: Response) => Record<string, unknown> | undefined;
+
+  // Function to get authentication headers for API requests
+  getAuthHeaders: (params: GetAuthHeadersParams) => Record<string, string> | undefined;
+
+  // Error constructor for handling errors
+  ErrorConstructor: AppErrorConstructor;
 }
 ```
 
-#### validationSchema
+### Validation Schema
+
+By default, for path params in REST actions, the following regexp is used: `/^((?!(\.\.|\?|#|\\|\/)).)*$/i`.
+If the parameter value does not pass validation, the `GATEWAY_INVALID_PARAM_VALUE` error is returned.
 
-By default, for path params in rest actions used the following regexp: `/^((?!(\.\.|\?|#|\\|\/)).)*$/i`.
-If the parameter value does not pass validation, the `GATEWAY_INVALID_PARAM_VALUE` value is returned.
+You can use the `DEFAULT_VALIDATION_SCHEMA` from `lib/constants.ts` as a starting point:
 
-### Usage in Node.js
+```javascript
+export const DEFAULT_VALIDATION_SCHEMA = {
+  additionalProperties: {
+    oneOf: [
+      {
+        type: 'number',
+      },
+      {
+        type: 'string',
+        pattern: '^((?!(\\.\\.|\\?|#|\\\\|\\/)).)*$',
+      },
+      {
+        type: 'object',
+      },
+    ],
+  },
+};
+```
+
+### Using the API in Node.js
 
-Upon gateway initialization, in addition to exporting the controller, it also exports an `api` object, which represents the core for executing requests to the backend.
+In addition to the Express controller, the gateway also exports an `api` object for making direct requests to backend services:
 
 ```javascript
 import {getGatewayControllers} from '@gravity-ui/gateway';
@@ -146,15 +248,18 @@ const config = {
 };
 
 const {api: gatewayApi} = getGatewayControllers({root: Schema}, config);
-```
-
-Subsequently, in the code, you can use it as follows:
 
-```javascript
-gatewayApi[service][action](actionConfig);
+// Use the API to make requests
+const result = await gatewayApi.serviceName.actionName({
+  authArgs: {token: 'auth-token'},
+  requestId: '123',
+  headers: {},
+  args: {param1: 'value1'},
+  ctx: context,
+});
 ```
 
-`actionConfig` has the following structure:
+The `actionConfig` parameter has the following structure:
 
 ```typescript
 interface ApiActionConfig<Context, TRequestData> {
@@ -171,50 +276,49 @@ interface ApiActionConfig<Context, TRequestData> {
 ### Schema Scopes
 
 Each schema belongs to its own namespace. Service and action names between schemas are completely independent and can coincide. Each scope has an independent gRPC context, which eliminates naming conflicts between schemas in proto files.
-The scope name is the key in the first parameter of the object containing the schemas.
+
+The scope name is the key in the first parameter of the object containing the schemas:
 
 ```javascript
 const schemasByScopes = {scope1: schema1, scope2: schema2};
 ```
 
-Example with two scope namespaces: `root` and `anotherScope`.
+Example with two scope namespaces: `root` and `anotherScope`:
 
 ```javascript
 import {getGatewayControllers} from '@gravity-ui/gateway';
 
 const {
-    controller, // Controller
-    api, // API (for Node.js environment)
-} = getGatewayControllers({ root: rootSchema, anotherScope: anotherSchema}, config);
+  controller, // Controller
+  api, // API (for Node.js environment)
+} = getGatewayControllers({root: rootSchema, anotherScope: anotherSchema}, config);
 
-// API calls are made by specifying the scope.
-const resultFromRoot = api.rootSchema.<root-service>.<root-action>(params);
-const resultFromAnother = api.anotherSchema.<another-service>.<another-action>(params);
+// API calls are made by specifying the scope
+const resultFromRoot = api.root.rootService.rootAction(params);
+const resultFromAnother = api.anotherScope.anotherService.anotherAction(params);
 ```
 
-There is a special scope called root. Its methods can be invoked without explicitly specifying the scope.
+There is a special scope called `root`. Its methods can be invoked without explicitly specifying the scope:
 
 ```javascript
-const resultFromRoot = api.rootSchema.<root-service>.<root-action>(params);
+const resultFromRoot = api.root.rootService.rootAction(params);
 // Same result
-const sameResultFromRoot = api.<root-service>.<root-action>(params);
+const sameResultFromRoot = api.rootService.rootAction(params);
 ```
 
-The controller for the expresskit will also expect the `:scope` parameter.
+The controller for expresskit will also expect the `:scope` parameter. If the scope parameter is not specified, the default scope is assumed to be `root`.
 
 ```javascript
 {
-    'POST   /<prefix>/:scope/:service/:action': {...}
+    'POST   /<prefix>/:scope/:service/:action': gatewayController
 }
 ```
 
-If the scope parameter is not specified, the default scope is assumed to be `root`.
-
-### Connecting a Specific Set of Actions
+### Connecting Specific Actions
 
-When initializing the `gateway`, there is an option to explicitly specify the actions that need to be connected from the schemas. To do this, provide a list of available client-side actions in the `actions` field in the config. If `actions` are not provided, all actions from the schemas are connected by default.
+You can explicitly specify which actions to connect from the schemas using the `actions` field in the config. If actions are not provided, all actions from the schemas are connected by default.
 
-```typescript
+```javascript
 import {getGatewayControllers} from '@gravity-ui/gateway';
 import rootSchema from '<schemas package>';
 import localSchema from '../shared/schemas';
@@ -223,49 +327,221 @@ const config = {
   installation: 'external',
   env: 'production',
   includeProtoRoots: ['...'],
-  actions: ['local.*', 'root.serviceA.*', 'root.serviceB.get'], // List of actions to be connected from the schemas. By default, all actions are connected.
+  actions: [
+    'local.*', // All actions from the 'local' scope
+    'root.serviceA.*', // All actions from 'serviceA' in the 'root' scope
+    'root.serviceB.getUser', // Only the 'getUser' action from 'serviceB' in the 'root' scope
+  ],
 };
 
 const {api: gatewayApi} = getGatewayControllers({root: rootSchema, local: localSchema}, config);
 ```
 
-The following combinations are available for specifying connected actions:
+Available patterns for specifying actions:
+
+- `<scope>.*` - all actions from the specified scope
+- `<scope>.<service>.*` - all actions from the specified service
+- `<scope>.<service>.<action>` - only the specified action
+
+**Note:** This configuration only affects client-side access. All actions remain accessible on the server side.
+
+### Overriding Endpoints
+
+You can override specific endpoints using the `GATEWAY_ENDPOINTS_OVERRIDES` environment variable. This is useful for testing environments.
+
+Example format:
+
+```javascript
+GATEWAY_ENDPOINTS_OVERRIDES = JSON.stringify({
+  serviceName: {
+    endpoint: 'https://example.com',
+  },
+  'example.exampleService': {
+    endpoint: 'https://overrided.example.com',
+  },
+});
+```
+
+### Authentication
+
+The gateway supports set up authentication through the `getAuthArgs` and `getAuthHeaders` config options:
+
+```javascript
+const config = {
+  // ...other config options
+
+  // Get authentication arguments for request
+  getAuthArgs: (req, res) => ({
+    token: req.authorization.token,
+  }),
+
+  // Generate authentication headers for backend requests
+  getAuthHeaders: (params) => {
+    if (!params?.token) return undefined;
+
+    return {
+      Authorization: `Bearer ${params.token}`,
+    };
+  },
+};
+```
+
+You can also define service-specific authentication by adding a `getAuthHeaders` function to individual actions:
+
+```javascript
+const schema = {
+  userService: {
+    serviceName: 'users',
+    endpoints: {...},
+    actions: {
+      getProfile: {
+        path: () => '/profile',
+        method: 'GET',
+        getAuthHeaders: (params) => ({
+          'X-Special-Auth': params.token,
+        }),
+      },
+    },
+  },
+};
+```
+
+### Error Handling
+
+The gateway provides several ways to handle errors:
+
+1. **Error constructor** through the `ErrorConstructor` (reqiured field) config option:
+
+```javascript
+class CustomError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = 'CustomError';
+    this.code = options.code || 'UNKNOWN_ERROR';
+    this.status = options.status || 500;
+    this.details = options.details;
+  }
+
+  static wrap(error) {
+    if (error instanceof CustomError) return error;
+    return new CustomError(error.message, {
+      code: error.code || 'INTERNAL_ERROR',
+      status: error.status || 500,
+    });
+  }
+}
+
+const config = {
+  // ...other config options
+  ErrorConstructor: CustomError,
+};
+```
+
+2. **Custom request error handling** through the `onRequestFailed` config option:
+
+```javascript
+const config = {
+  // ...other config options
+  onRequestFailed: (req, res, error) => {
+    console.error('Request failed:', error);
+    return res.status(error.status || 500).json({
+      error: error.message,
+      code: error.code,
+    });
+  },
+};
+```
+
+### Retryable Errors
+
+#### REST-actions
+
+The **default** retry condition for REST-actions includes the following conditions:
+
+- Network errors (detected by `axiosRetry.isNetworkError`)
+- Other retryable errors (detected by `axiosRetry.isRetryableError`)
+
+You can customize retry behavior for using the `axiosRetryCondition` config option:
+
+```javascript
+const config = {
+  // ...other config options
+  axiosRetryCondition: (error) => {
+    // Custom logic to determine if the request should be retried
+    return error.code === 'TIMEOUT';
+  },
+};
+```
+
+#### gRPC-actions
+
+The **default** retry condition for gRPC-actions includes the certain gRPC status codes:
 
-- `<scope>.*` - all actions from the scope scope are connected (for example, `local.*`)
-- `<scope>.<service>.*` - all actions from the service service are connected (for example, `root.serviceA.*`)
-- `<scope>.<service>.action` - only the specified action is connected (for example, `root.serviceB.get`)
+- `UNAVAILABLE`
+- `CANCELLED`
+- `ABORTED`
+- `UNKNOWN`
 
-**Important.** The actions configuration only affects the list of actions that will be accessible from the client (e.g., via the `sdk`). All actions from the schemas will continue to be accessible on Node.js.
+You can customize retry behavior using the `grpcRetryCondition` config option:
 
-### GATEWAY_ENDPOINTS_OVERRIDES
+```javascript
+const config = {
+  // ...other config options
+  grpcRetryCondition: (error) => {
+    // Custom logic to determine if the request should be retried
+    return error.code === 'RESOURCE_EXHAUSTED';
+  },
+};
+```
 
-Through the `GATEWAY_ENDPOINTS_OVERRIDES` environment variable, you can override specific endpoints. This can be useful for testing environments. A simple example: `{"serviceName":{"endpoint":"https://example.com"}}`. You can find a more detailed format in the OverrideParams interface and test examples.
+For gRPC-requests that fail with `DEADLINE_EXCEEDED`, the service connection is recreated before retrying if config option `grpcRecreateService` is not set to `false`.
 
 ### gRPC Reflection for gRPC Actions
 
-Instead of using gRPC proto files, a gRPC action can determine the structure of the service and the required method through reflection.
+Instead of using gRPC proto files, you can use gRPC reflection to determine the structure of services and methods.
+
+**Prerequisites:**
 
-**Enabling Reflection**
+1. Install the `grpc-reflection-js` package:
 
-To use reflection, you need to:
+   ```shell
+   npm install --save grpc-reflection-js
+   ```
 
-- Install the `grpc-reflection-js` package as a peer dependency.
-- Apply patches to the `protobufjs` library. You can do this in the following ways:
+2. Apply patches to the `protobufjs` library:
+   - Add `npx gateway-reflection-patch` to your project's `postinstall` script. This assumes that protobufjs is located in the root of node_modules.
+   - Copy the patch from the library's patches folder to your project root, install [patch-package](https://www.npmjs.com/package/patch-package), and add the patch-package command to the `postinstall` script. In this case, you need to keep an eye on updates to the patches in the gateway when updating it.
 
-  a) Add `npx gateway-reflection-patch` to the `postinstall` script in your project and execute it. This assumes that protobufjs is located in the root of node_modules.
+If you encounter a "cannot run in wd [...]" error during Docker build, you can add unsafe-perm = true to your .npmrc file.
 
-  b) Copy the patch from the library's patches folder to your project's root, install [patch-package](https://www.npmjs.com/package/patch-package), and add the `patch-package` command to the `postinstall` script. In this case, you need to keep an eye on updates to the patches in the gateway when updating it.
+3. Configure your action to use reflection:
 
-  If you encounter a "cannot run in wd [...]" error during Docker build, you can add unsafe-perm = true to your .npmrc file as described here.
+   ```javascript
+   import {GrpcReflection} from '@gravity-ui/gateway';
 
-- In the `action` configuration, replace the `protoPath` option with the `reflection` option and set its value to the appropriate `GrpcReflection` enum value. For reflection to work, the endpoint must support it.
+   const schema = {
+     userService: {
+       serviceName: 'users',
+       endpoints: {...},
+       actions: {
+         getUser: {
+           protoKey: 'users.v1.UserService',
+           action: 'GetUser',
+           reflection: GrpcReflection.OnFirstRequest,
+           // Optional: refresh reflection cache every 3600 seconds (1 hour)
+           reflectionRefreshSec: 3600,
+         },
+       },
+     },
+   };
+   ```
 
-Possible values for `GrpcReflection`, affecting the caching of reflection results:
+**Reflection Options:**
 
-- `OnFirstRequest` - Perform reflection on the first action request. Use cached reflections.
-- `OnEveryRequest` - Perform reflection before every action request. Do not use cached reflections.
+- `GrpcReflection.OnFirstRequest` - Perform reflection on the first request. Use cached reflections.
+- `GrpcReflection.OnEveryRequest` - Perform reflection before every request. Do not use cached reflections.
 
-For the `OnFirstRequest` options you can specify the reflectionRefreshSec parameter, which indicates how often in seconds the reflection cache can be updated in the background. Cache updates happen asynchronously and don't block the current request. The initial reflection request with an empty cache might introduce some delay in the request.
+For the `OnFirstRequest` options you can specify the `reflectionRefreshSec` parameter, which indicates how often in seconds the reflection cache can be updated in the background. Cache updates happen asynchronously and don't block the current request. The initial reflection request with an empty cache might introduce some delay in the request.
 
 **Particularities**
 
@@ -282,3 +558,23 @@ For development, you need to apply the patch locally using the command `npx patc
 **ChannelCredentials Type Mismatch Error**
 
 This error can occur due to duplicate installations of the `@grpc/grpc-js` library. It's recommended to ensure that all versions of this library are aligned and consistent to avoid this issue.
+
+## Development
+
+### Running Tests
+
+```shell
+# Run unit tests
+npm test
+
+# Run integration tests
+npm run test-integration
+```
+
+### Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+## License
+
+MIT

package/build/components/grpc.js

@@ -600,13 +600,17 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                                 (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_1.isRetryableError)(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) {
-                                ctx.logError(`Request failed, retrying ${retries--} more times`);
+                                (0, common_2.handleError)(ErrorConstructor, error, ctx, `Request failed, retrying ${retries--} more times`, {
+                                    serviceName,
+                                    actionName,
+                                    debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                                });
                                 // Update pointer to re-created client in local service variable
                                 try {
                                     service = await getService(args);

package/build/index.d.ts

@@ -2,7 +2,7 @@ import { ApiWithRoot, GatewayConfig, GatewayRequest, GatewayResponse, SchemasByS
 import { GatewayContext } from './models/context';
 export * from './utils/typed-api';
 export * from './utils/grpc-reflection';
-export { isRetryableError as isRetryableGrpcError } from './utils/grpc';
+export { isRetryableGrpcError } from './utils/grpc';
 export * from './models/common';
 export * from './models/context';
 export * from './models/error';

package/build/index.js

@@ -40,7 +40,7 @@ const overrideEndpoints_1 = __importDefault(require("./utils/overrideEndpoints")
 __exportStar(require("./utils/typed-api"), exports);
 __exportStar(require("./utils/grpc-reflection"), exports);
 var grpc_2 = require("./utils/grpc");
-Object.defineProperty(exports, "isRetryableGrpcError", { enumerable: true, get: function () { return grpc_2.isRetryableError; } });
+Object.defineProperty(exports, "isRetryableGrpcError", { enumerable: true, get: function () { return grpc_2.isRetryableGrpcError; } });
 __exportStar(require("./models/common"), exports);
 __exportStar(require("./models/context"), exports);
 __exportStar(require("./models/error"), exports);

package/build/utils/grpc.d.ts

@@ -1,5 +1,5 @@
 import * as grpc from '@grpc/grpc-js';
 import * as protobufjs from 'protobufjs';
 export declare function decodeAnyMessageRecursively(root: protobufjs.Root, message?: unknown, decodeAnyMessageProtoLoaderOptions?: protobufjs.IConversionOptions): unknown;
-export declare function isRetryableError(error?: grpc.ServiceError): boolean;
+export declare function isRetryableGrpcError(error?: grpc.ServiceError): boolean;
 export declare function isRecreateServiceError(error?: grpc.ServiceError): boolean;

package/build/utils/grpc.js

@@ -1,7 +1,7 @@
 "use strict";
 /* eslint-disable camelcase */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRecreateServiceError = exports.isRetryableError = exports.decodeAnyMessageRecursively = void 0;
+exports.isRecreateServiceError = exports.isRetryableGrpcError = exports.decodeAnyMessageRecursively = void 0;
 const constants_1 = require("../constants");
 function isEncodedMessage(message) {
     return Boolean(message.type_url && message.value);
@@ -40,13 +40,13 @@ function decodeAnyMessageRecursively(root, message, decodeAnyMessageProtoLoaderO
     }
 }
 exports.decodeAnyMessageRecursively = decodeAnyMessageRecursively;
-function isRetryableError(error) {
+function isRetryableGrpcError(error) {
     if (!error) {
         return false;
     }
     return constants_1.RETRYABLE_STATUS_CODES.includes(error.code);
 }
-exports.isRetryableError = isRetryableError;
+exports.isRetryableGrpcError = isRetryableGrpcError;
 function isRecreateServiceError(error) {
     if (!error) {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/gateway",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "",
   "license": "MIT",
   "main": "build/index.js",
@@ -42,8 +42,8 @@
     "@grpc/grpc-js": "^1.9.9",
     "@grpc/proto-loader": "^0.7.8",
     "ajv": "^8.12.0",
-    "axios": "^1.3.5",
-    "axios-retry": "^3.4.0",
+    "axios": "^1.8.3",
+    "axios-retry": "^3.9.1",
     "lodash": "^4.17.21",
     "object-sizeof": "^2.6.5",
     "protobufjs": "^7.2.5",