@gravity-ui/gateway 4.1.0 → 4.1.1-alpha.0

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

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

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

@@ -16,18 +16,30 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCredentialsMap = exports.createRoot = void 0;
+exports.createRoot = createRoot;
+exports.getCredentialsMap = getCredentialsMap;
+exports.createGrpcAction = createGrpcAction;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const grpc = __importStar(require("@grpc/grpc-js"));
@@ -36,29 +48,29 @@ const lodash_1 = __importDefault(require("lodash"));
 const object_sizeof_1 = __importDefault(require("object-sizeof"));
 const protobufjs = __importStar(require("protobufjs"));
 const uuid_1 = require("uuid");
-const constants_1 = require("../constants");
-const common_1 = require("../models/common");
-const common_2 = require("../utils/common");
-const grpc_1 = require("../utils/grpc");
-const grpc_reflection_1 = require("../utils/grpc-reflection");
-const parse_error_1 = require("../utils/parse-error");
-const 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')] });
+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 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 source_dir_js_1 = require("../utils/source-dir.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(source_dir_js_1.sourceDir, '../proto')] });
 function createRoot(includeGrpcPaths) {
     const root = new protobufjs.Root();
-    root.loadSync(path_1.default.resolve(__dirname, '../../proto/google/rpc/code.proto'));
-    root.loadSync(path_1.default.resolve(__dirname, '../../proto/google/rpc/error_details.proto'));
-    root.loadSync(path_1.default.resolve(__dirname, '../../proto/google/rpc/status.proto'));
+    root.loadSync(path_1.default.resolve(source_dir_js_1.sourceDir, '../proto/google/rpc/code.proto'));
+    root.loadSync(path_1.default.resolve(source_dir_js_1.sourceDir, '../proto/google/rpc/error_details.proto'));
+    root.loadSync(path_1.default.resolve(source_dir_js_1.sourceDir, '../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_1.patchProtoPathResolver)(root, grpcLoaderOptions.includeDirs);
+    (0, proto_path_resolver_js_1.patchProtoPathResolver)(root, grpcLoaderOptions.includeDirs);
     return root;
 }
-exports.createRoot = createRoot;
 function getCredentialsMap(caCertificatePath) {
     let certificate;
     if (caCertificatePath && fs_1.default.existsSync(caCertificatePath)) {
@@ -70,7 +82,6 @@ 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) => {
@@ -78,21 +89,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_1.decodeAnyMessageRecursively)(packageRoot, fieldValue, decodeAnyMessageProtoLoaderOptions));
+                lodash_1.default.set(response, parsedFieldName, (0, grpc_js_1.decodeAnyMessageRecursively)(packageRoot, fieldValue, decodeAnyMessageProtoLoaderOptions));
             }
         }
         catch (error) {
-            (0, common_2.handleError)(ErrorConstructor, error, ctx, 'Message decoding failed', { fieldName });
+            (0, common_js_2.handleError)(ErrorConstructor, error, ctx, 'Message decoding failed', { fieldName });
         }
     });
 }
 function createMetadata({ options, actionConfig, config, params, serviceName, ctx, }) {
     var _a;
     const { headers, requestId, authArgs } = actionConfig;
-    const proxyHeaders = [...constants_1.DEFAULT_PROXY_HEADERS];
+    const proxyHeaders = [...constants_js_1.DEFAULT_PROXY_HEADERS];
     let metadata = {
         'x-request-id': requestId,
-        'accept-language': headers[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru,
+        'accept-language': headers[constants_js_1.DEFAULT_LANG_HEADER] || constants_js_1.Lang.Ru,
     };
     if (typeof options.proxyHeaders === 'function') {
         Object.assign(metadata, options.proxyHeaders(Object.assign({}, headers), 'grpc'));
@@ -138,7 +149,7 @@ function createMetadata({ options, actionConfig, config, params, serviceName, ct
     return serviceMetadata;
 }
 function createActionEndpoint(endpointData) {
-    return (0, common_2.isExtendedActionEndpoint)(endpointData) ? endpointData.path : endpointData;
+    return (0, common_js_2.isExtendedActionEndpoint)(endpointData) ? endpointData.path : endpointData;
 }
 const packageObjectsMap = new Map();
 const serviceInstancesMap = {};
@@ -170,7 +181,7 @@ function clearInstancesCache(service, instancesMap, cachePath, closeTimeout, ctx
 function getChannelCredential(config, endpointData, credentials) {
     let endpointInsecure;
     let endpointSecureWithoutRootCert;
-    if ((0, common_2.isExtendedGrpcActionEndpoint)(endpointData)) {
+    if ((0, common_js_2.isExtendedGrpcActionEndpoint)(endpointData)) {
         endpointInsecure = endpointData === null || endpointData === void 0 ? void 0 : endpointData.insecure;
         endpointSecureWithoutRootCert = endpointData === null || endpointData === void 0 ? void 0 : endpointData.secureWithoutRootCert;
     }
@@ -219,7 +230,7 @@ async function refreshCache(actionEndpoint, config, endpointData, grpcOptions, c
     }
 }
 function getServiceInstanceReflectCached(config, endpointData, grpcOptions, credentials) {
-    if (config.reflection === common_1.GrpcReflection.OnEveryRequest) {
+    if (config.reflection === common_js_1.GrpcReflection.OnEveryRequest) {
         return getServiceInstanceReflect(config, endpointData, grpcOptions, credentials);
     }
     const actionEndpoint = createActionEndpoint(endpointData);
@@ -241,24 +252,24 @@ function getServiceInstanceReflectCached(config, endpointData, grpcOptions, cred
 }
 async function getServiceInstanceReflect(config, endpointData, grpcOptions, credentials, isRefreshCache) {
     const actionEndpoint = createActionEndpoint(endpointData);
-    const endpointInsecure = (0, common_2.isExtendedGrpcActionEndpoint)(endpointData)
+    const endpointInsecure = (0, common_js_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_2.isExtendedGrpcActionEndpoint)(endpointData)
+    const endpointGrpcOptions = (0, common_js_2.isExtendedGrpcActionEndpoint)(endpointData)
         ? endpointData.grpcOptions || {}
         : {};
-    const combinedGrpcOptions = Object.assign(Object.assign(Object.assign({}, constants_1.DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions);
+    const combinedGrpcOptions = Object.assign(Object.assign(Object.assign({}, constants_js_1.DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions);
     let loadedRoot;
-    if (config.reflection === common_1.GrpcReflection.OnEveryRequest || isRefreshCache) {
-        loadedRoot = await (0, grpc_reflection_1.getReflectionRoot)(actionEndpoint, config.protoKey, creds, combinedGrpcOptions, isRefreshCache);
+    if (config.reflection === common_js_1.GrpcReflection.OnEveryRequest || isRefreshCache) {
+        loadedRoot = await (0, grpc_reflection_js_1.getReflectionRoot)(actionEndpoint, config.protoKey, creds, combinedGrpcOptions, isRefreshCache);
     }
     else {
-        loadedRoot = await (0, grpc_reflection_1.getCachedReflectionRoot)(actionEndpoint, config.protoKey, creds, combinedGrpcOptions);
+        loadedRoot = await (0, grpc_reflection_js_1.getCachedReflectionRoot)(actionEndpoint, config.protoKey, creds, combinedGrpcOptions);
     }
     const descriptor = loadedRoot.toDescriptor('proto3');
-    const definition = protoLoader.loadFileDescriptorSetFromObject(descriptor, constants_1.DEFAULT_PROTO_LOADER_OPTIONS);
+    const definition = protoLoader.loadFileDescriptorSetFromObject(descriptor, constants_js_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);
@@ -292,10 +303,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_2.isExtendedGrpcActionEndpoint)(endpointData)
+        const endpointGrpcOptions = (0, common_js_2.isExtendedGrpcActionEndpoint)(endpointData)
             ? endpointData.grpcOptions || {}
             : {};
-        serviceInstance = new Service(actionEndpoint, creds, Object.assign(Object.assign(Object.assign({}, constants_1.DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions));
+        serviceInstance = new Service(actionEndpoint, creds, Object.assign(Object.assign(Object.assign({}, constants_js_1.DEFAULT_GRPC_OPTIONS), grpcOptions), endpointGrpcOptions));
         // Save pointer to service in cache
         lodash_1.default.set(serviceInstancesMap, cacheKey, serviceInstance);
     }
@@ -322,7 +333,7 @@ async function getResponseData({ config, response, ctx, packageRoot, args, Error
             ctx.log('Transformed response data');
         }
         catch (error) {
-            (0, common_2.handleError)(ErrorConstructor, error, ctx, 'Transform response data failed');
+            (0, common_js_2.handleError)(ErrorConstructor, error, ctx, 'Transform response data failed');
         }
     }
     return responseData;
@@ -362,8 +373,8 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
         if (endpointData) {
             const actionEndpoint = createActionEndpoint(endpointData);
             if ('reflection' in config &&
-                (config.reflection === common_1.GrpcReflection.OnEveryRequest ||
-                    config.reflection === common_1.GrpcReflection.OnFirstRequest)) {
+                (config.reflection === common_js_1.GrpcReflection.OnEveryRequest ||
+                    config.reflection === common_js_1.GrpcReflection.OnFirstRequest)) {
                 getService = () => getServiceInstanceReflectCached(config, endpointData, grpcOptions, credentials);
                 recreateService = (service, closeTimeout, ctx) => {
                     const cachePath = [config.protoKey, actionEndpoint];
@@ -387,7 +398,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
         var _a;
         const { args, requestId, headers, ctx: parentCtx, userId } = actionConfig;
         const { action } = config;
-        const lang = headers[constants_1.DEFAULT_LANG_HEADER] || constants_1.Lang.Ru; // header might be empty string
+        const lang = headers[constants_js_1.DEFAULT_LANG_HEADER] || constants_js_1.Lang.Ru; // header might be empty string
         const ctx = parentCtx.create(`Gateway ${serviceName} ${actionName} [grpc]`, {
             tags: {
                 action: actionName,
@@ -412,7 +423,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_1.VERSION,
+            'x-gateway-version': constants_js_1.VERSION,
         };
         if ('protoPath' in config) {
             debugHeaders['x-api-request-protopath'] = config.protoPath;
@@ -427,10 +438,10 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 }
             }
         }
-        ctx.log('Initiating request', { debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders) });
+        ctx.log('Initiating request', { debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders) });
         const sendStats = (status, data) => {
             if (options === null || options === void 0 ? void 0 : options.sendStats) {
-                options.sendStats(Object.assign(Object.assign({}, data), { restStatus: status }), (0, redact_sensitive_headers_1.redactSensitiveHeaders)(parentCtx, headers), parentCtx, { debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders) });
+                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) });
             }
             else {
                 ctx.stats(Object.assign(Object.assign({}, requestData), { responseStatus: status }));
@@ -441,7 +452,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_2.sanitizeDebugHeaders)(debugHeaders) }, grpcError.getGatewayError()));
+                actionName, debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders) }, grpcError.getGatewayError()));
             ctx.end();
         }
         let params;
@@ -450,7 +461,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 params = await config.params(args, headers, { ctx });
             }
             catch (error) {
-                (0, common_2.handleError)(ErrorConstructor, error, ctx, 'Getting config params failed');
+                (0, common_js_2.handleError)(ErrorConstructor, error, ctx, 'Getting config params failed');
             }
         }
         let service;
@@ -458,7 +469,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             service = await getService(args);
         }
         catch (error) {
-            (0, common_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
+            (0, common_js_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
             throw error;
         }
         // eslint-disable-next-line complexity
@@ -473,7 +484,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_1.GrpcError(errorText, {
+                throw new parse_error_js_1.GrpcError(errorText, {
                     status: 400,
                     code: 'ENDPOINT_NOT_FOUND',
                     message: errorText,
@@ -482,9 +493,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_1.validateArgs)(args, validationSchema) : false;
+            const invalidParams = validationSchema ? (0, validate_js_1.validateArgs)(args, validationSchema) : false;
             if (invalidParams) {
-                throw new parse_error_1.GrpcError('Invalid params', {
+                throw new parse_error_js_1.GrpcError('Invalid params', {
                     status: 400,
                     code: 'INVALID_PARAMS',
                     message: 'Validation failed',
@@ -494,7 +505,7 @@ 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_1.DEFAULT_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_js_1.DEFAULT_TIMEOUT;
             const serviceOptions = {
                 deadline: Date.now() + timeout,
             };
@@ -508,7 +519,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 ctx,
             });
             if (!service[action]) {
-                reject(new parse_error_1.GrpcError('Not found action', {
+                reject(new parse_error_js_1.GrpcError('Not found action', {
                     status: 400,
                     code: 'GRPC_ACTION_NOT_FOUND',
                     message: `Not found action ${action} in ${serviceKey}`,
@@ -518,22 +529,22 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             switch (config.type) {
                 case 'serverStream': {
                     ctx.log('Creating serverStream request', {
-                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                        debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
                     });
                     const actionCall = service[action].bind(service);
                     const stream = actionCall(body, serviceMetadata, serviceOptions);
                     stream.on('error', (error) => {
                         ctx.log('ServerStream error', {
-                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                            debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
                         });
-                        processError(new parse_error_1.GrpcError('ClientReadableStream error', (0, parse_error_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
+                        processError(new parse_error_js_1.GrpcError('ClientReadableStream error', (0, parse_error_js_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
                     });
                     stream.on('status', (status) => {
                         ctx.log('ServerStream status changed', status);
                     });
                     stream.on('end', () => {
                         ctx.log('ServerStream request completed', {
-                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                            debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
                         });
                         ctx.end();
                     });
@@ -542,10 +553,10 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 }
                 case 'clientStream': {
                     ctx.log('Creating clientStream request', {
-                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                        debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
                     });
                     if (!actionConfig.callback) {
-                        throw new parse_error_1.GrpcError('Invalid action type', {
+                        throw new parse_error_js_1.GrpcError('Invalid action type', {
                             status: 400,
                             code: 'ACTION_CALLBACK_REQUIRED',
                             message: `Client stream actions require callback function`,
@@ -558,22 +569,22 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 }
                 case 'bidi': {
                     ctx.log('Creating serverStream request', {
-                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                        debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
                     });
                     const actionCall = service[action].bind(service);
                     const stream = actionCall(serviceMetadata, serviceOptions);
                     stream.on('error', (error) => {
                         ctx.log('BidiStream error', {
-                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                            debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
                         });
-                        processError(new parse_error_1.GrpcError('BidiStream error', (0, parse_error_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
+                        processError(new parse_error_js_1.GrpcError('BidiStream error', (0, parse_error_js_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
                     });
                     stream.on('status', (status) => {
                         ctx.log('BidiStream status changed', status);
                     });
                     stream.on('end', () => {
                         ctx.log('BidiStream request completed', {
-                            debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                            debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
                         });
                         ctx.end();
                     });
@@ -585,7 +596,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 }
                 default: {
                     ctx.log('Starting unary request', {
-                        debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders),
+                        debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
                     });
                     let retries = (_d = config.retries) !== null && _d !== void 0 ? _d : 0;
                     let actionCall = service[action].bind(service);
@@ -596,8 +607,8 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                             requestData.requestTime = endRequestTime - startRequestTime;
                             const shouldRecreateService = error &&
                                 options.grpcRecreateService &&
-                                (0, grpc_1.isRecreateServiceError)(error);
-                            const shouldRetry = error && retries && (0, grpc_1.isRetryableError)(error);
+                                (0, grpc_js_1.isRecreateServiceError)(error);
+                            const shouldRetry = error && retries && (0, grpc_js_1.isRetryableError)(error);
                             if (shouldRecreateService) {
                                 ctx.log(`Service client for ${config.protoKey} is going to be re-created`);
                                 recreateService(service, timeout * 1.5, ctx, args);
@@ -609,7 +620,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                                     service = await getService(args);
                                 }
                                 catch (error) {
-                                    (0, common_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
+                                    (0, common_js_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
                                     throw error;
                                 }
                                 // Update service
@@ -618,7 +629,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                                 return;
                             }
                             if (error) {
-                                reject(new parse_error_1.GrpcError('gRPC request error', (0, parse_error_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
+                                reject(new parse_error_js_1.GrpcError('gRPC request error', (0, parse_error_js_1.parseGrpcError)(error, root, lang, config.decodeAnyMessageProtoLoaderOptions), error));
                                 return;
                             }
                             const responseData = await getResponseData({
@@ -633,7 +644,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                             const responseHeaders = {};
                             if (config.proxyResponseHeaders) {
                                 const proxyResponseHeaders = [];
-                                const headersFromMetadata = (0, common_2.getHeadersFromMetadata)(trailingMetadata);
+                                const headersFromMetadata = (0, common_js_2.getHeadersFromMetadata)(trailingMetadata);
                                 if (typeof config.proxyResponseHeaders === 'function') {
                                     Object.assign(responseHeaders, config.proxyResponseHeaders(headersFromMetadata, 'grpc'));
                                 }
@@ -647,10 +658,10 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                                     }
                                 }
                             }
-                            Object.assign(debugHeaders, (0, common_2.getHeadersFromMetadata)(trailingMetadata, 'x-metadata-'));
+                            Object.assign(debugHeaders, (0, common_js_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_2.sanitizeDebugHeaders)(debugHeaders),
+                                debugHeaders: (0, common_js_2.sanitizeDebugHeaders)(debugHeaders),
                             });
                             ctx.end();
                             return resolve({ responseData, responseHeaders, debugHeaders });
@@ -663,10 +674,9 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 }
             }
         }).catch((error) => {
-            const grpcError = (0, parse_error_1.isGrpcError)(error) ? error : (0, parse_error_1.grpcErrorFactory)(error);
+            const grpcError = (0, parse_error_js_1.isGrpcError)(error) ? error : (0, parse_error_js_1.grpcErrorFactory)(error);
             processError(grpcError);
             return Promise.reject({ error: grpcError.getGatewayError(), debugHeaders });
         });
     };
 }
-exports.default = createGrpcAction;

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

@@ -1,7 +1,7 @@
-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';
+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';
 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/{build → dist/commonjs}/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 = 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");
+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");
 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_1.generateContextApi)(api, Object.assign(Object.assign({}, context), { ctx }));
+        const contextApi = (0, create_context_api_js_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({ headers: actionConfig.headers, lang: actionConfig.headers[constants_js_1.DEFAULT_LANG_HEADER] || constants_js_1.Lang.Ru, ctx }, extra));
             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_1.handleError)(ErrorConstructor, e, ctx, 'Request failed', {
+                (0, common_js_1.handleError)(ErrorConstructor, e, ctx, 'Request failed', {
                     actionName,
                     serviceName,
                 });
                 throw e;
             }
             if (e instanceof Error) {
-                const parsedError = (0, parse_error_1.parseMixedError)(e);
-                (0, common_1.handleError)(ErrorConstructor, e, ctx, 'Request failed', {
+                const parsedError = (0, parse_error_js_1.parseMixedError)(e);
+                (0, common_js_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_1.handleError)(ErrorConstructor, e, ctx, 'Request failed');
+            (0, common_js_1.handleError)(ErrorConstructor, e, ctx, 'Request failed');
             throw {
                 error: e,
             };
@@ -63,4 +63,3 @@ function createMixedAction(config, api, serviceName, actionName, extra, ErrorCon
         }
     };
 }
-exports.createMixedAction = createMixedAction;

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

@@ -1,8 +1,8 @@
-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<{
+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<{
     responseData: unknown;
-    responseHeaders?: Headers | undefined;
+    responseHeaders?: Headers;
     debugHeaders: Headers;
 }>;