@gravity-ui/gateway 4.5.0 → 4.7.0

package/README.md

@@ -7,7 +7,6 @@ A flexible and powerful Express controller for working with REST and gRPC APIs i
 - [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)
@@ -92,9 +91,18 @@ type AxiosRetryCondition = IAxiosRetryConfig['retryCondition'];
 
 type ControllerType = 'rest' | 'grpc';
 
+type ProxyHeadersFunctionExtra = {
+  service: string;
+  action: string;
+
+  protopath?: string;
+  protokey?: string;
+};
+
 type ProxyHeadersFunction = (
   headers: IncomingHttpHeaders,
   type: ControllerType,
+  extra: ProxyHeadersFunctionExtra,
 ) => IncomingHttpHeaders;
 type ProxyHeaders = string[] | ProxyHeadersFunction;
 type ResponseContentType = AxiosResponse['headers']['Content-Type'];
@@ -205,6 +213,49 @@ interface GatewayConfig {
 }
 ```
 
+### `proxyHeaders`
+
+`GatewayConfig.proxyHeaders` is an optional method that allows setting headers for requests at the entire `gateway` level:
+
+```javascript
+const proxyHeaders = (headers, actionType, {service, action}) => {
+  const normalizedHeaders = {...headers};
+
+  if (actionType === 'rest' && service === 'mail') {
+    normalizedHeaders['x-mail-service-action'] = action;
+  }
+
+  return normalizedHeaders;
+};
+
+const {controller: gatewayController} = getGatewayControllers(
+  {root: Schema},
+  {...config, proxyHeaders},
+);
+```
+
+You can set headers for a specific action using `ApiServiceBaseActionConfig.proxyHeaders`:
+
+```javascript
+const schema = {
+  userService: {
+    serviceName: 'users',
+    endpoints: {...},
+    actions: {
+      getProfile: {
+        path: () => '/profile',
+        method: 'GET',
+        proxyHeaders: (headers) => ({...headers, ['x-users-service-action']: 'get-profile'}),
+      },
+    },
+  },
+};
+```
+
+The `GatewayConfig.proxyHeaders` and `ApiServiceBaseActionConfig.proxyHeaders` are merged when the action is called. The strategy for merging headers is not guaranteed.
+
+It is recommended to use `GatewayConfig.proxyHeaders` for assigning headers that are common to the entire application or a large number of actions. Otherwise, it is preferable to use `ApiServiceBaseActionConfig.proxyHeaders`.
+
 ### Validation Schema
 
 By default, for path params in REST actions, the following regexp is used: `/^((?!(\.\.|\?|#|\\|\/)).)*$/i`.

package/build/components/grpc.js

@@ -86,7 +86,7 @@ function decodeResponse(response, packageRoot, ctx, encodedFields = [], ErrorCon
         }
     });
 }
-function createMetadata({ options, actionConfig, config, params, serviceName, ctx, }) {
+function createMetadata({ options, actionConfig, config, params, serviceName, proxyHeadersCaller, ctx, }) {
     var _a;
     const { headers, requestId, authArgs } = actionConfig;
     const proxyHeaders = [...constants_1.DEFAULT_PROXY_HEADERS];
@@ -95,13 +95,13 @@ function createMetadata({ options, actionConfig, config, params, serviceName, ct
         'accept-language': headers[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru,
     };
     if (typeof options.proxyHeaders === 'function') {
-        Object.assign(metadata, options.proxyHeaders(Object.assign({}, headers), 'grpc'));
+        Object.assign(metadata, proxyHeadersCaller(options.proxyHeaders));
     }
     else if (Array.isArray(options.proxyHeaders)) {
         proxyHeaders.push(...options.proxyHeaders);
     }
     if (typeof config.proxyHeaders === 'function') {
-        Object.assign(metadata, config.proxyHeaders(Object.assign({}, headers), 'grpc'));
+        Object.assign(metadata, proxyHeadersCaller(config.proxyHeaders));
     }
     else if (Array.isArray(config.proxyHeaders)) {
         proxyHeaders.push(...config.proxyHeaders);
@@ -385,7 +385,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
     }
     return async function action(actionConfig) {
         var _a;
-        const { args, requestId, headers, ctx: parentCtx, userId } = actionConfig;
+        const { args, requestId, headers, ctx: parentCtx, userId, abortSignal } = actionConfig;
         const { action } = config;
         const lang = headers[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru; // header might be empty string
         const ctx = parentCtx.create(`Gateway ${serviceName} ${actionName} [grpc]`, {
@@ -401,7 +401,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             service: serviceName,
             action: actionName,
             requestTime: 0,
-            requestId: actionConfig.requestId,
+            requestId,
             requestMethod: action,
             requestUrl: config.protoKey,
             traceId: ((_a = ctx.getTraceId) === null || _a === void 0 ? void 0 : _a.call(ctx)) || '',
@@ -414,11 +414,19 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             'x-request-id': requestId,
             'x-gateway-version': constants_1.VERSION,
         };
-        if ('protoPath' in config) {
-            debugHeaders['x-api-request-protopath'] = config.protoPath;
+        const protopath = 'protoPath' in config ? config.protoPath : undefined;
+        if (protopath) {
+            debugHeaders['x-api-request-protopath'] = protopath;
         }
+        let proxyHeadersExtra;
+        const proxyHeadersCaller = (proxyHeadersFunc) => {
+            if (proxyHeadersExtra === undefined) {
+                proxyHeadersExtra = (0, common_2.getProxyHeadersArgs)(serviceName, actionName, config);
+            }
+            return proxyHeadersFunc(Object.assign({}, headers), 'rest', proxyHeadersExtra);
+        };
         if (typeof options.proxyDebugHeaders === 'function') {
-            Object.assign(debugHeaders, options.proxyDebugHeaders(Object.assign({}, headers), 'grpc'));
+            Object.assign(debugHeaders, proxyHeadersCaller(options.proxyDebugHeaders));
         }
         else if (Array.isArray(options.proxyDebugHeaders)) {
             for (const headerName of options.proxyDebugHeaders) {
@@ -461,6 +469,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             (0, common_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
             throw error;
         }
+        let stopListeningForAbort = null;
         // eslint-disable-next-line complexity
         return new Promise((resolve, reject) => {
             var _a, _b, _c, _d;
@@ -505,6 +514,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 config,
                 params,
                 serviceName,
+                proxyHeadersCaller,
                 ctx,
             });
             if (!service[action]) {
@@ -522,6 +532,12 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                     });
                     const actionCall = service[action].bind(service);
                     const stream = actionCall(body, serviceMetadata, serviceOptions);
+                    stopListeningForAbort = (0, grpc_1.listenForAbort)({
+                        signal: abortSignal,
+                        config,
+                        call: stream,
+                        reject,
+                    });
                     stream.on('error', (error) => {
                         ctx.log('ServerStream error', {
                             debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
@@ -532,6 +548,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                         ctx.log('ServerStream status changed', status);
                     });
                     stream.on('end', () => {
+                        stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
                         ctx.log('ServerStream request completed', {
                             debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                         });
@@ -553,6 +570,15 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                     }
                     const actionCall = service[action].bind(service);
                     const stream = actionCall(serviceMetadata, serviceOptions, actionConfig.callback);
+                    stopListeningForAbort = (0, grpc_1.listenForAbort)({
+                        signal: abortSignal,
+                        config,
+                        call: stream,
+                        reject,
+                    });
+                    stream.once('end', () => {
+                        stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
+                    });
                     resolve({ debugHeaders, stream });
                     return;
                 }
@@ -562,6 +588,12 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                     });
                     const actionCall = service[action].bind(service);
                     const stream = actionCall(serviceMetadata, serviceOptions);
+                    stopListeningForAbort = (0, grpc_1.listenForAbort)({
+                        signal: abortSignal,
+                        config,
+                        call: stream,
+                        reject,
+                    });
                     stream.on('error', (error) => {
                         ctx.log('BidiStream error', {
                             debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
@@ -572,6 +604,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                         ctx.log('BidiStream status changed', status);
                     });
                     stream.on('end', () => {
+                        stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
                         ctx.log('BidiStream request completed', {
                             debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                         });
@@ -619,12 +652,14 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                                     (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);
                                 callAction();
                                 return;
                             }
                             if (error) {
+                                stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
                                 reject(new parse_error_1.GrpcError('gRPC request error', (0, parse_error_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
                                 return;
                             }
@@ -660,11 +695,18 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                                 debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
                             });
                             ctx.end();
+                            stopListeningForAbort === null || stopListeningForAbort === void 0 ? void 0 : stopListeningForAbort();
                             return resolve({ responseData, responseHeaders, debugHeaders });
                         });
                         call.on('status', (status) => {
                             trailingMetadata = status.metadata.toJSON();
                         });
+                        stopListeningForAbort = (0, grpc_1.listenForAbort)({
+                            signal: abortSignal,
+                            config,
+                            call,
+                            reject,
+                        });
                     };
                     callAction();
                 }
@@ -672,6 +714,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
         }).catch((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 });
         });
     };

package/build/components/mixed.js

@@ -28,7 +28,7 @@ function createMixedAction(config, api, serviceName, actionName, extra, ErrorCon
         });
         const contextApi = (0, create_context_api_1.generateContextApi)(api, Object.assign(Object.assign({}, context), { ctx }));
         try {
-            const responseData = await config(contextApi, args, Object.assign({ headers: actionConfig.headers, lang: actionConfig.headers[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru, ctx }, extra));
+            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,

package/build/components/rest.js

@@ -40,7 +40,7 @@ function createRestAction(endpoints, config, serviceKey, actionName, options, Er
     /* eslint-disable complexity */
     return async function action(actionConfig) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
-        const { args, requestId, headers: requestHeaders, ctx: parentCtx, authArgs, userId, } = actionConfig;
+        const { args, requestId, headers: requestHeaders, ctx: parentCtx, authArgs, userId, abortSignal, } = actionConfig;
         const debugHeaders = {};
         const lang = requestHeaders[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru; // header might be empty string
         const serviceName = (options === null || options === void 0 ? void 0 : options.serviceName) || serviceKey;
@@ -113,14 +113,21 @@ function createRestAction(endpoints, config, serviceKey, actionName, options, Er
             'accept-language': lang,
             'x-gateway-version': constants_1.VERSION,
         };
+        let proxyHeadersExtra;
+        const proxyHeadersCaller = (proxyHeadersFunc) => {
+            if (proxyHeadersExtra === undefined) {
+                proxyHeadersExtra = (0, common_1.getProxyHeadersArgs)(serviceName, actionName);
+            }
+            return proxyHeadersFunc(Object.assign({}, requestHeaders), 'rest', proxyHeadersExtra);
+        };
         if (typeof options.proxyHeaders === 'function') {
-            Object.assign(actionHeaders, options.proxyHeaders(Object.assign({}, requestHeaders), 'rest'));
+            Object.assign(actionHeaders, proxyHeadersCaller(options.proxyHeaders));
         }
         else if (Array.isArray(options.proxyHeaders)) {
             proxyHeaders.push(...options.proxyHeaders);
         }
         if (typeof config.proxyHeaders === 'function') {
-            Object.assign(actionHeaders, config.proxyHeaders(Object.assign({}, requestHeaders), 'rest'));
+            Object.assign(actionHeaders, proxyHeadersCaller(config.proxyHeaders));
         }
         else if (Array.isArray(config.proxyHeaders)) {
             proxyHeaders.push(...config.proxyHeaders);
@@ -185,7 +192,7 @@ function createRestAction(endpoints, config, serviceKey, actionName, options, Er
             debugHeaders['x-api-content-type'] = headers['content-type'];
         }
         if (typeof options.proxyDebugHeaders === 'function') {
-            Object.assign(debugHeaders, options.proxyDebugHeaders(Object.assign({}, requestHeaders), 'rest'));
+            Object.assign(debugHeaders, proxyHeadersCaller(options.proxyDebugHeaders));
         }
         else if (Array.isArray(options.proxyDebugHeaders)) {
             for (const headerName of options.proxyDebugHeaders) {
@@ -220,6 +227,7 @@ function createRestAction(endpoints, config, serviceKey, actionName, options, Er
             params: query,
             headers: ctx ? Object.assign(Object.assign({}, ctx.getMetadata()), headers) : headers,
             maxRedirects: config.maxRedirects,
+            signal: config.abortOnClientDisconnect ? abortSignal : undefined,
         };
         if (config.paramsSerializer) {
             Object.assign(requestConfig, {

package/build/index.js

@@ -176,6 +176,11 @@ function generateGatewayApiController(schemasByScope, Api, config, controllerAct
         }
         const args = req.method === 'GET' ? req.query : req.body;
         try {
+            const abortController = new AbortController();
+            const handleCloseConnection = () => {
+                abortController.abort();
+            };
+            req.connection.once('close', handleCloseConnection);
             const apiAction = Api[scope][service][action];
             if (onBeforeAction) {
                 const actionConfig = (_c = (_b = (_a = schemasByScope[scope]) === null || _a === void 0 ? void 0 : _a[service]) === null || _b === void 0 ? void 0 : _b.actions) === null || _c === void 0 ? void 0 : _c[action];
@@ -194,7 +199,9 @@ function generateGatewayApiController(schemasByScope, Api, config, controllerAct
                 args,
                 authArgs: config.getAuthArgs(req, res),
                 userId,
+                abortSignal: abortController.signal,
             });
+            req.connection.removeListener('close', handleCloseConnection);
             if (withDebugHeaders) {
                 res.set(debugHeaders);
             }

package/build/models/common.d.ts

@@ -32,6 +32,7 @@ export interface ApiActionConfig<Context extends GatewayContext, TRequestData, T
     callback?: (response: TResponseData) => void;
     authArgs?: Record<string, unknown>;
     userId?: string;
+    abortSignal?: AbortSignal;
 }
 export interface GRPCActionData {
     [key: string]: unknown;
@@ -67,7 +68,13 @@ export interface GatewayError {
 }
 export type GrpcRetryCondition = (error: ServiceError) => boolean;
 export type AxiosRetryCondition = IAxiosRetryConfig['retryCondition'];
-export type ProxyHeadersFunction = (headers: IncomingHttpHeaders, type: ControllerType) => IncomingHttpHeaders;
+export type ProxyHeadersFunctionExtra = {
+    service: string;
+    action: string;
+    protopath?: string;
+    protokey?: string;
+};
+export type ProxyHeadersFunction = (headers: IncomingHttpHeaders, type: ControllerType, extra: ProxyHeadersFunctionExtra) => IncomingHttpHeaders;
 export type ProxyHeaders = string[] | ProxyHeadersFunction;
 export type ProxyResponseHeadersFunction = (headers: Headers, type: ControllerType) => Headers;
 export type ProxyResponseHeaders = string[] | ProxyResponseHeadersFunction;
@@ -131,6 +138,7 @@ export interface ApiServiceBaseActionConfig<Context extends GatewayContext, TOut
     proxyHeaders?: ProxyHeaders;
     proxyResponseHeaders?: ProxyResponseHeaders;
     metadata?: Record<string, string | number | boolean>;
+    abortOnClientDisconnect?: boolean;
 }
 export interface ApiServiceRestActionConfig<Context extends GatewayContext, TOutput, TParams = undefined, TTransformed = TOutput> extends ApiServiceBaseActionConfig<Context, TOutput, TParams, TTransformed> {
     method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
@@ -168,6 +176,7 @@ export interface ApiServiceMixedExtra<Context extends GatewayContext, Req extend
     ctx: Context;
     config: GatewayConfig<Context, Req, Res>;
     grpcContext: GrpcContext;
+    abortSignal?: AbortSignal;
 }
 export type ApiServiceMixedActionConfig<Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse, TOutput, TParams = undefined, TTransformed = TOutput> = (api: unknown, args: TParams, extra: ApiServiceMixedExtra<Context, Req, Res>) => Promise<TTransformed>;
 export type ApiServiceActionConfig<Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse, TOutput, TParams = undefined, TTransformed = TOutput> = ApiServiceRestActionConfig<Context, TOutput, TParams, TTransformed> | ApiServiceGrpcActionConfig<Context, TOutput, TParams, TTransformed> | ApiServiceMixedActionConfig<Context, Req, Res, TOutput, TParams, TTransformed>;

package/build/utils/common.d.ts

@@ -1,6 +1,6 @@
 import * as grpc from '@grpc/grpc-js';
 import _ from 'lodash';
-import { ActionEndpoint, ExtendedActionEndpoint, ExtendedGrpcActionEndpoint, ExtendedRestActionEndpoint, Headers } from '../models/common';
+import { ActionEndpoint, ApiServiceGrpcActionConfig, ExtendedActionEndpoint, ExtendedGrpcActionEndpoint, ExtendedRestActionEndpoint, Headers, ProxyHeadersFunctionExtra } from '../models/common';
 import { Dict, GatewayContext } from '../models/context';
 import { AppErrorConstructor } from '../models/error';
 export declare function isExtendedActionEndpoint(endpoint: ActionEndpoint): endpoint is ExtendedActionEndpoint;
@@ -13,3 +13,4 @@ export declare function getKeys<T extends object>(obj: T): (keyof T)[];
 export declare function sanitizeDebugHeaders(debugHeaders: Headers): _.Omit<Headers, "x-api-request-body">;
 export declare function getHeadersFromMetadata(metadata: Record<string, grpc.MetadataValue[]>, prefix?: string): Record<string, string>;
 export declare function handleError<Context extends GatewayContext>(ErrorConstructor: AppErrorConstructor, error: unknown, ctx: Context, message: string, extra?: Dict): void;
+export declare const getProxyHeadersArgs: <Context extends GatewayContext>(serviceName: string, actionName: string, grpcConfig?: ApiServiceGrpcActionConfig<Context, any, any> | undefined) => ProxyHeadersFunctionExtra;

package/build/utils/common.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleError = exports.getHeadersFromMetadata = exports.sanitizeDebugHeaders = exports.getKeys = exports.isExtendedRestActionEndpoint = exports.isExtendedGrpcActionEndpoint = exports.isExtendedActionEndpoint = void 0;
+exports.getProxyHeadersArgs = exports.handleError = exports.getHeadersFromMetadata = exports.sanitizeDebugHeaders = exports.getKeys = exports.isExtendedRestActionEndpoint = exports.isExtendedGrpcActionEndpoint = exports.isExtendedActionEndpoint = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 function isExtendedActionEndpoint(endpoint) {
     return (endpoint === null || endpoint === void 0 ? void 0 : endpoint.path) !== undefined;
@@ -49,3 +49,14 @@ function handleError(ErrorConstructor, error, ctx, message, extra) {
     }
 }
 exports.handleError = handleError;
+const getProxyHeadersArgs = (serviceName, actionName, grpcConfig) => {
+    const protopath = grpcConfig && 'protoPath' in grpcConfig ? grpcConfig.protoPath : undefined;
+    const protokey = grpcConfig === null || grpcConfig === void 0 ? void 0 : grpcConfig.protoKey;
+    return {
+        service: serviceName,
+        action: actionName,
+        protopath,
+        protokey,
+    };
+};
+exports.getProxyHeadersArgs = getProxyHeadersArgs;

package/build/utils/grpc.d.ts

@@ -1,5 +1,15 @@
 import * as grpc from '@grpc/grpc-js';
+import { ClientDuplexStream, ClientReadableStream, ClientUnaryCall, ClientWritableStream } 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 isRetryableGrpcError(error?: grpc.ServiceError): boolean;
 export declare function isRecreateServiceError(error?: grpc.ServiceError): boolean;
+export type ListenForAbortArgs = {
+    signal?: AbortSignal;
+    config: {
+        abortOnClientDisconnect?: boolean;
+    };
+    call: ClientUnaryCall | ClientReadableStream<unknown> | ClientWritableStream<unknown> | ClientDuplexStream<unknown, unknown>;
+    reject: (err: Error) => void;
+};
+export declare function listenForAbort({ signal, config, call, reject }: ListenForAbortArgs): () => void;

package/build/utils/grpc.js

@@ -1,8 +1,9 @@
 "use strict";
 /* eslint-disable camelcase */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRecreateServiceError = exports.isRetryableGrpcError = exports.decodeAnyMessageRecursively = void 0;
+exports.listenForAbort = exports.isRecreateServiceError = exports.isRetryableGrpcError = exports.decodeAnyMessageRecursively = void 0;
 const constants_1 = require("../constants");
+const parse_error_1 = require("./parse-error");
 function isEncodedMessage(message) {
     return Boolean(message.type_url && message.value);
 }
@@ -54,3 +55,25 @@ function isRecreateServiceError(error) {
     return constants_1.RECREATE_SERVICE_CODES.includes(error.code);
 }
 exports.isRecreateServiceError = isRecreateServiceError;
+function listenForAbort({ signal, config, call, reject }) {
+    if (!signal || !config.abortOnClientDisconnect) {
+        return () => null;
+    }
+    const handleAbortSignal = () => {
+        call.cancel();
+        reject(new parse_error_1.GrpcError('Request was cancelled.', {
+            status: 499,
+            code: 'REQUEST_WAS_CANCELLED',
+            message: 'Request was cancelled because the original connection was disconnected.',
+        }));
+    };
+    if (signal.aborted) {
+        handleAbortSignal();
+        return () => null;
+    }
+    signal.addEventListener('abort', handleAbortSignal);
+    return () => {
+        signal.removeEventListener('abort', handleAbortSignal);
+    };
+}
+exports.listenForAbort = listenForAbort;

package/build/utils/parse-error.js

@@ -116,6 +116,10 @@ function parseRestError(error, lang) {
             status = 504;
             description = lang === constants_1.Lang.Ru ? 'Превышено время ожидания ответа' : 'Timeout exceeded';
         }
+        else if (code === 'ERR_CANCELED') {
+            status = 499;
+            description = lang === constants_1.Lang.Ru ? 'Запрос был отменен.' : 'Request was cancelled.';
+        }
         else {
             status = 500;
             description =

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/gateway",
-  "version": "4.5.0",
+  "version": "4.7.0",
   "description": "",
   "license": "MIT",
   "main": "build/index.js",