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

package/dist/esm/utils/common.js

@@ -0,0 +1,48 @@
+import _ from 'lodash';
+export function isExtendedActionEndpoint(endpoint) {
+    return (endpoint === null || endpoint === void 0 ? void 0 : endpoint.path) !== undefined;
+}
+export function isExtendedGrpcActionEndpoint(endpoint) {
+    return ((endpoint === null || endpoint === void 0 ? void 0 : endpoint.grpcOptions) !== undefined ||
+        (endpoint === null || endpoint === void 0 ? void 0 : endpoint.insecure) !== undefined ||
+        (endpoint === null || endpoint === void 0 ? void 0 : endpoint.secureWithoutRootCert) !== undefined);
+}
+export function isExtendedRestActionEndpoint(endpoint) {
+    return (endpoint === null || endpoint === void 0 ? void 0 : endpoint.axiosConfig) !== undefined;
+}
+export function getKeys(obj) {
+    return Object.keys(obj);
+}
+/**
+ * This function should only use to sanitize debugHeaders that are creating in our code
+ */
+export function sanitizeDebugHeaders(debugHeaders) {
+    return _.omit(debugHeaders, ['x-api-request-body']);
+}
+export function getHeadersFromMetadata(metadata, prefix = '') {
+    return Object.entries(metadata).reduce((headers, [key, values]) => {
+        headers[`${prefix}${key}`] = values.filter((value) => typeof value === 'string').join(' ');
+        return headers;
+    }, {});
+}
+export function handleError(ErrorConstructor, error, ctx, message, extra) {
+    if (error instanceof Error) {
+        ctx.logError(message, ErrorConstructor.wrap(error), extra);
+    }
+    else if (typeof error === 'string') {
+        ctx.logError(message, { error }, extra);
+    }
+    else {
+        ctx.logError(message, error, extra);
+    }
+}
+export 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,
+    };
+};

package/dist/esm/utils/create-context-api.d.ts

@@ -0,0 +1,4 @@
+import { ApiActionConfig, ApiByScope, ContextApiWithRoot, GatewayRequest, GatewayResponse, SchemasByScope } from '../models/common.js';
+import { GatewayContext } from '../models/context.js';
+export type RequestContext<Context extends GatewayContext> = Omit<ApiActionConfig<Context, never>, 'args'>;
+export declare function generateContextApi<TFullSchema extends SchemasByScope, Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse>(baseApi: ApiByScope<TFullSchema, Context, Req, Res>, requestContext: RequestContext<Context>): ContextApiWithRoot<TFullSchema>;

package/dist/esm/utils/create-context-api.js

@@ -0,0 +1,38 @@
+import _ from 'lodash';
+import { getKeys } from './common.js';
+function createContextApiForScope(api, requestContext) {
+    return _.reduce(api, (acc, service, serviceName) => {
+        acc[serviceName] = _.reduce(service, (accService, action, actionName) => {
+            accService[actionName] = (args) => action(Object.assign(Object.assign({}, requestContext), { args })).then((response) => response.responseData ||
+                response
+                    .stream);
+            return accService;
+        }, {});
+        return acc;
+    }, {});
+}
+export function generateContextApi(baseApi, requestContext) {
+    var _a;
+    const contextApi = _.reduce(baseApi, (contextApi, scope, scopeName) => {
+        contextApi[scopeName] = createContextApiForScope(scope, requestContext);
+        return contextApi;
+    }, {});
+    const api = contextApi;
+    const rootScope = contextApi.root;
+    if (rootScope) {
+        for (const rootService of getKeys(rootScope)) {
+            const curScope = (_a = api[rootService]) !== null && _a !== void 0 ? _a : {};
+            for (const rootAction of getKeys(rootScope[rootService])) {
+                const rootServiceFunc = rootScope[rootService][rootAction];
+                if (curScope[rootAction]) {
+                    for (const curScopeAction of getKeys(curScope[rootAction])) {
+                        rootServiceFunc[curScopeAction] = curScope[rootAction][curScopeAction];
+                    }
+                }
+                curScope[rootAction] = rootServiceFunc;
+            }
+            api[rootService] = curScope;
+        }
+    }
+    return api;
+}

package/dist/esm/utils/grpc-reflection.d.ts

@@ -0,0 +1,28 @@
+import type { ChannelCredentials } from '@grpc/grpc-js';
+type DescriptorExtensionProto = string[] | {
+    includeProtoRoots: string[];
+    filenames: string[];
+};
+/**
+ * @param actionEndpoint
+ * @param protoKey
+ * @param credentials
+ * @param grpcOptions
+ * @param descriptorExtensionProto
+ * @returns Promise<protobufjs.Root>.
+ * use toDescriptor for use with protoLoader.
+ * use toJSON for get a JSON descriptor.
+ */
+export declare function getCachedReflectionRoot(actionEndpoint: string, protoKey: string, credentials: ChannelCredentials, grpcOptions?: object, descriptorExtensionProto?: DescriptorExtensionProto): Promise<any>;
+/**
+ * @param actionEndpoint
+ * @param protoKey
+ * @param credentials
+ * @param grpcOptions
+ * @param addToCache
+ * @returns Promise<protobufjs.Root>.
+ * use toDescriptor for use with protoLoader.
+ * use toJSON for get a JSON descriptor.
+ */
+export declare function getReflectionRoot(actionEndpoint: string, protoKey: string, credentials: ChannelCredentials, grpcOptions?: object, addToCache?: boolean): Promise<any>;
+export {};

package/dist/esm/utils/grpc-reflection.js

@@ -0,0 +1,72 @@
+import _ from 'lodash';
+import protobufjs from 'protobufjs';
+import { patchProtoPathResolver } from './proto-path-resolver.js';
+const reflectionClientsMap = {};
+async function getCachedClient(actionEndpoint, credentials, grpcOptions, descriptorExtensionProto) {
+    const cacheKey = [actionEndpoint, JSON.stringify([grpcOptions, descriptorExtensionProto])];
+    let clientWithCache = _.get(reflectionClientsMap, cacheKey);
+    if (!clientWithCache) {
+        const grpcReflection = await import('grpc-reflection-js');
+        let descriptorRoot;
+        if (descriptorExtensionProto) {
+            descriptorRoot = protobufjs.Root.fromJSON(
+            // @ts-expect-error no typings for default export
+            (await import('protobufjs/ext/descriptor/index.js')).default);
+            if (Array.isArray(descriptorExtensionProto)) {
+                descriptorRoot.loadSync(descriptorExtensionProto);
+            }
+            else {
+                patchProtoPathResolver(descriptorRoot, descriptorExtensionProto.includeProtoRoots);
+                descriptorRoot.loadSync(descriptorExtensionProto.filenames);
+            }
+        }
+        const client = new grpcReflection.Client(actionEndpoint, credentials, grpcOptions, undefined, 
+        // @ts-ignore this parameter is present only in the patched version
+        descriptorRoot);
+        clientWithCache = { client, reflectionRootPromiseMap: {} };
+        _.set(reflectionClientsMap, cacheKey, clientWithCache);
+    }
+    return clientWithCache;
+}
+/**
+ * @param actionEndpoint
+ * @param protoKey
+ * @param credentials
+ * @param grpcOptions
+ * @param descriptorExtensionProto
+ * @returns Promise<protobufjs.Root>.
+ * use toDescriptor for use with protoLoader.
+ * use toJSON for get a JSON descriptor.
+ */
+export async function getCachedReflectionRoot(actionEndpoint, protoKey, credentials, grpcOptions, descriptorExtensionProto) {
+    const { client, reflectionRootPromiseMap } = await getCachedClient(actionEndpoint, credentials, grpcOptions, descriptorExtensionProto);
+    const cacheKey = [actionEndpoint, protoKey];
+    let cachedRootPromise = _.get(reflectionRootPromiseMap, cacheKey);
+    if (!cachedRootPromise) {
+        cachedRootPromise = client.fileContainingSymbol(protoKey);
+        _.set(reflectionRootPromiseMap, cacheKey, cachedRootPromise);
+        cachedRootPromise.catch(() => {
+            _.set(reflectionRootPromiseMap, cacheKey, undefined);
+        });
+    }
+    const loadedRoot = await cachedRootPromise;
+    return loadedRoot;
+}
+/**
+ * @param actionEndpoint
+ * @param protoKey
+ * @param credentials
+ * @param grpcOptions
+ * @param addToCache
+ * @returns Promise<protobufjs.Root>.
+ * use toDescriptor for use with protoLoader.
+ * use toJSON for get a JSON descriptor.
+ */
+export async function getReflectionRoot(actionEndpoint, protoKey, credentials, grpcOptions, addToCache) {
+    const { client, reflectionRootPromiseMap } = await getCachedClient(actionEndpoint, credentials, grpcOptions);
+    const loadedRoot = await client.fileContainingSymbol(protoKey);
+    if (addToCache) {
+        _.set(reflectionRootPromiseMap, [actionEndpoint, protoKey], Promise.resolve(loadedRoot));
+    }
+    return loadedRoot;
+}

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

@@ -0,0 +1,15 @@
+import * as grpc from '@grpc/grpc-js';
+import { ClientDuplexStream, ClientReadableStream, ClientUnaryCall, ClientWritableStream } from '@grpc/grpc-js';
+import 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/dist/esm/utils/grpc.js

@@ -0,0 +1,72 @@
+/* eslint-disable camelcase */
+import { DEFAULT_PROTO_LOADER_OPTIONS, RECREATE_SERVICE_CODES, RETRYABLE_STATUS_CODES, } from '../constants.js';
+import { GrpcError } from './parse-error.js';
+function isEncodedMessage(message) {
+    return Boolean(message.type_url && message.value);
+}
+export function decodeAnyMessageRecursively(root, message, decodeAnyMessageProtoLoaderOptions) {
+    if (!message || typeof message !== 'object') {
+        return message;
+    }
+    if (Array.isArray(message)) {
+        return message.map((innerMessage) => decodeAnyMessageRecursively(root, innerMessage, decodeAnyMessageProtoLoaderOptions));
+    }
+    if (typeof message === 'object' && !isEncodedMessage(message)) {
+        return Object.entries(message).reduce((res, [key, value]) => {
+            res[key] = decodeAnyMessageRecursively(root, value, decodeAnyMessageProtoLoaderOptions);
+            return res;
+        }, {});
+    }
+    const lastSlashIndex = message.type_url.lastIndexOf('/');
+    if (lastSlashIndex < 0) {
+        return message;
+    }
+    const typeName = message.type_url.substring(lastSlashIndex + 1);
+    try {
+        const type = root.lookupType(typeName);
+        const decodedMessage = type.toObject(type.decode(message.value), Object.assign(Object.assign({}, DEFAULT_PROTO_LOADER_OPTIONS), decodeAnyMessageProtoLoaderOptions));
+        if (typeof decodedMessage === 'object' &&
+            !Array.isArray(decodedMessage) &&
+            !decodedMessage['@type']) {
+            Object.assign(decodedMessage, { '@type': message.type_url });
+        }
+        return decodeAnyMessageRecursively(root, decodedMessage, decodeAnyMessageProtoLoaderOptions);
+    }
+    catch (error) {
+        console.error(`Failed to lookup ${typeName}`, error);
+        return message;
+    }
+}
+export function isRetryableGrpcError(error) {
+    if (!error) {
+        return false;
+    }
+    return RETRYABLE_STATUS_CODES.includes(error.code);
+}
+export function isRecreateServiceError(error) {
+    if (!error) {
+        return false;
+    }
+    return RECREATE_SERVICE_CODES.includes(error.code);
+}
+export function listenForAbort({ signal, config, call, reject }) {
+    if (!signal || !config.abortOnClientDisconnect) {
+        return () => null;
+    }
+    const handleAbortSignal = () => {
+        call.cancel();
+        reject(new 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);
+    };
+}

package/dist/esm/utils/overrideEndpoints/index.d.ts

@@ -0,0 +1,2 @@
+import { overrideEndpoints } from './overrideEndpoints.js';
+export default overrideEndpoints;

package/dist/esm/utils/overrideEndpoints/index.js

@@ -0,0 +1,2 @@
+import { overrideEndpoints } from './overrideEndpoints.js';
+export default overrideEndpoints;

package/dist/esm/utils/overrideEndpoints/overrideEndpoints.d.ts

@@ -0,0 +1,17 @@
+import { ActionEndpoint, SchemasByScope } from '../../index.js';
+export interface OverrideParams {
+    [serviceKeyScope: string]: {
+        [endpointName: string]: ActionEndpoint;
+    };
+}
+/**
+ * Overrides endpoints in the schema according to overrideParams
+ * @param originalSchema Schema for the gateway
+ * @param overrideParams Definitions of endpoints for services in the format {[<scope>.<service key>]: {[<endpointName>]: ActionEndpoint}}
+ * If <scope> is not specified, root is assumed.
+ * Example: '{serviceName: {endpoint: "https://example.com"}}'
+ * @param installation
+ * @param env
+ * @return new overridden schema
+ */
+export declare function overrideEndpoints<T extends SchemasByScope>(originalSchema: T, overrideParams: OverrideParams, installation: string | undefined, env: string | undefined): T;

package/dist/esm/utils/overrideEndpoints/overrideEndpoints.js

@@ -0,0 +1,96 @@
+import _ from 'lodash';
+function parseOverrideEndpointsParams(params) {
+    const parsedParams = [];
+    for (const [serviceKeyScope, serviceKeyValues] of Object.entries(params)) {
+        for (const [endpointName, config] of Object.entries(serviceKeyValues)) {
+            let scope = 'root';
+            let serviceKey = serviceKeyScope;
+            const pointInd = serviceKey.indexOf('.');
+            if (pointInd >= 0) {
+                scope = serviceKey.slice(0, pointInd);
+                serviceKey = serviceKey.slice(pointInd + 1);
+            }
+            parsedParams.push({
+                scope,
+                serviceKey,
+                endpointName,
+                config,
+            });
+        }
+    }
+    return parsedParams;
+}
+function getKeys(obj) {
+    return Object.keys(obj);
+}
+function deepCopy(obj) {
+    const res = Object.assign({}, obj);
+    getKeys(res).forEach((key) => {
+        if (typeof res[key] === 'object' && !Array.isArray(res[key]) && res[key] !== null) {
+            res[key] = deepCopy(res[key]);
+        }
+    });
+    return res;
+}
+/**
+ * Overrides endpoints in the schema according to overrideParams
+ * @param originalSchema Schema for the gateway
+ * @param overrideParams Definitions of endpoints for services in the format {[<scope>.<service key>]: {[<endpointName>]: ActionEndpoint}}
+ * If <scope> is not specified, root is assumed.
+ * Example: '{serviceName: {endpoint: "https://example.com"}}'
+ * @param installation
+ * @param env
+ * @return new overridden schema
+ */
+export function overrideEndpoints(originalSchema, overrideParams, installation, env) {
+    if (!installation) {
+        console.warn('overrideEndpoints: installation empty');
+        return originalSchema;
+    }
+    if (!env) {
+        console.warn('overrideEndpoints: env empty');
+        return originalSchema;
+    }
+    const schema = deepCopy(originalSchema);
+    const parsedParams = parseOverrideEndpointsParams(overrideParams);
+    parsedParams.forEach((overrideConfig) => {
+        var _a;
+        const curService = (_a = schema[overrideConfig.scope]) === null || _a === void 0 ? void 0 : _a[overrideConfig.serviceKey];
+        if (!curService || !curService.actions || !curService.endpoints) {
+            console.warn('overrideEndpoints: incorrect service ' +
+                overrideConfig.scope +
+                '.' +
+                overrideConfig.serviceKey);
+            return;
+        }
+        const endpoints = curService.endpoints;
+        const envEndpoints = _.get(endpoints, [installation, env]);
+        if (!envEndpoints) {
+            console.warn('overrideEndpoints: ' + [installation, env] + ' not exists in envEndpoints');
+            return;
+        }
+        if (overrideConfig.endpointName) {
+            if (!envEndpoints[overrideConfig.endpointName]) {
+                console.warn('overrideEndpoints: incorrect endpointName ' + overrideConfig.endpointName);
+            }
+            overrideEndpoint(envEndpoints, overrideConfig.endpointName, overrideConfig);
+        }
+    });
+    return schema;
+}
+function isExtendedEndpointConfig(config) {
+    return typeof config === 'object';
+}
+function overrideEndpoint(envEndpoints, endpointName, overrideConfig) {
+    const config = envEndpoints[endpointName];
+    if (isExtendedEndpointConfig(config)) {
+        if (typeof overrideConfig.config === 'string') {
+            config.path = overrideConfig.config;
+        }
+        else {
+            Object.assign(config, overrideConfig.config);
+        }
+        return;
+    }
+    envEndpoints[endpointName] = overrideConfig.config;
+}

package/dist/esm/utils/package-root.d.ts

@@ -0,0 +1 @@
+export declare const packageRoot: string;

package/dist/esm/utils/package-root.js

@@ -0,0 +1,8 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { sourceDir } from './source-dir.js';
+let packageRootTest = path.resolve(sourceDir, '../package.json');
+if (!fs.existsSync(packageRootTest)) {
+    packageRootTest = path.resolve(sourceDir, '../../package.json');
+}
+export const packageRoot = path.dirname(packageRootTest);

package/dist/esm/utils/parse-error.d.ts

@@ -0,0 +1,30 @@
+import * as grpc from '@grpc/grpc-js';
+import protobufjs from 'protobufjs';
+import { Lang } from '../constants.js';
+import { GatewayError } from '../models/common.js';
+import { AppErrorConstructor } from '../models/error.js';
+export declare function parseMixedError(e: Error & {
+    code?: string;
+}): {
+    status: number;
+    message: string;
+    code: string;
+    debug: {
+        originalError: Error & {
+            code?: string;
+        };
+        stack: string | undefined;
+    };
+};
+export declare function parseRestError(error: any, lang?: string): GatewayError;
+export declare function parseGrpcError(error: grpc.ServiceError, packageRoot: protobufjs.Root, lang?: Lang, decodeAnyMessageProtoLoaderOptions?: protobufjs.IConversionOptions): GatewayError;
+export declare class GrpcError extends Error {
+    private parsedError;
+    private rawError;
+    constructor(message: string, parsedError: GatewayError, rawError?: grpc.ServiceError);
+    getGatewayError(): GatewayError;
+    getRawError(): grpc.ServiceError | undefined;
+    getAppError(ErrorConstructor: AppErrorConstructor): Error;
+}
+export declare function isGrpcError(error: Error | GrpcError): error is GrpcError;
+export declare function grpcErrorFactory(error: Error): GrpcError;

package/dist/esm/utils/parse-error.js

@@ -0,0 +1,214 @@
+import _ from 'lodash';
+import { Lang } from '../constants.js';
+import { decodeAnyMessageRecursively } from './grpc.js';
+const DEFAULT_GATEWAY_CODE = 'GATEWAY_REQUEST_ERROR';
+const DEFAULT_GATEWAY_MESSAGE = 'Gateway request error';
+export function parseMixedError(e) {
+    return {
+        status: 500,
+        message: String(e.message || DEFAULT_GATEWAY_MESSAGE),
+        code: String(e.code || DEFAULT_GATEWAY_CODE),
+        debug: {
+            originalError: e,
+            stack: e.stack,
+        },
+    };
+}
+function getErrorTitle(error) {
+    const prop = _.propertyOf(error);
+    const details = prop('details[0]');
+    if (details) {
+        return prop('details[0].type') || prop('details[0].code') || prop('code');
+    }
+    return prop('type') || prop('code');
+}
+function getErrorMessage(error) {
+    const prop = _.propertyOf(error);
+    const message = prop('message');
+    const detail = prop('detail');
+    const detailsMessage = prop('details[0].message');
+    if (message) {
+        return message;
+    }
+    if (detailsMessage) {
+        return detailsMessage;
+    }
+    if (detail) {
+        return prop('detail.Description') || prop('detail.Body') || detail;
+    }
+    return '';
+}
+function getStatusByGrpcCode(code) {
+    switch (code) {
+        case 0:
+            return 200;
+        case 1:
+            return 499;
+        case 2:
+            return 500;
+        case 3:
+            return 400;
+        case 4:
+            return 504;
+        case 5:
+            return 404;
+        case 6:
+            return 409;
+        case 7:
+            return 403;
+        case 8:
+            return 429;
+        case 9:
+            return 400;
+        case 10:
+            return 409;
+        case 11:
+            return 400;
+        case 12:
+            return 501;
+        case 13:
+            return 500;
+        case 14:
+            return 503;
+        case 15:
+            return 500;
+        case 16:
+            return 401;
+        default:
+            return 500;
+    }
+}
+export function parseRestError(error, lang) {
+    const prop = _.propertyOf(error);
+    let status = 500;
+    let title;
+    let description;
+    let details;
+    let type;
+    let code;
+    let debug;
+    if (prop('response')) {
+        const responseData = prop('response.data');
+        const statusTitle = `${prop('response.status')} ${prop('response.statusText')}`;
+        const errorTitle = getErrorTitle(responseData);
+        status = prop('response.status');
+        code = prop('response.data.code');
+        type = prop('response.data.type');
+        details = prop('response.data.details');
+        debug = prop('response.data.debug');
+        title = errorTitle ? errorTitle : statusTitle;
+        description = getErrorMessage(responseData);
+        if (status === 403) {
+            title = lang === Lang.Ru ? 'Доступ запрещен' : 'Access denied';
+        }
+    }
+    else {
+        code = prop('code');
+        title = lang === Lang.Ru ? 'Ошибка' : 'Error';
+        if (code === 'ECONNABORTED' || code === 'ETIMEDOUT') {
+            status = 504;
+            description = lang === Lang.Ru ? 'Превышено время ожидания ответа' : 'Timeout exceeded';
+        }
+        else if (code === 'ERR_CANCELED') {
+            status = 499;
+            description = lang === Lang.Ru ? 'Запрос был отменен.' : 'Request was cancelled.';
+        }
+        else {
+            status = 500;
+            description =
+                lang === Lang.Ru
+                    ? 'Произошла непредвиденная ошибка. Попробуйте обновить страницу через некоторое время.'
+                    : 'An unexpected error has occurred. Try to refresh the page in a few moments.';
+        }
+    }
+    return {
+        status,
+        message: String(description || DEFAULT_GATEWAY_MESSAGE),
+        code: String(code || DEFAULT_GATEWAY_CODE),
+        details: Object.assign({ type,
+            title,
+            description }, (typeof details === 'object' && !Array.isArray(details) ? details : { details })),
+        debug,
+    };
+}
+function decodeGrpcStatusMessage(metadata, packageRoot, decodeAnyMessageProtoLoaderOptions) {
+    const statusMessageBin = metadata.get('grpc-status-details-bin')[0];
+    if (!statusMessageBin) {
+        return undefined;
+    }
+    return decodeAnyMessageRecursively(packageRoot, {
+        type_url: 'type.googleapis.com/google.rpc.Status',
+        value: statusMessageBin,
+    }, decodeAnyMessageProtoLoaderOptions);
+}
+export function parseGrpcError(error, packageRoot, lang = Lang.Ru, decodeAnyMessageProtoLoaderOptions) {
+    let title = lang === Lang.Ru ? 'Ошибка' : 'Error';
+    if (error.code === 7) {
+        // Always redefine title for Access denied errors
+        title = lang === Lang.Ru ? 'Доступ запрещен' : 'Access denied';
+    }
+    let code = error.code;
+    let description = error.details;
+    let details;
+    if (error.metadata) {
+        try {
+            const statusMessage = decodeGrpcStatusMessage(error.metadata, packageRoot, decodeAnyMessageProtoLoaderOptions);
+            if (statusMessage) {
+                code = statusMessage.code;
+                description = statusMessage.message;
+                details = statusMessage.details;
+            }
+        }
+        catch (e) { }
+    }
+    // Always redefine description for Timeout exceeded errors
+    if (error.code === 4) {
+        description = lang === Lang.Ru ? 'Превышено время ожидания ответа' : 'Timeout exceeded';
+    }
+    // Use default description if description is undefined, but not for Access denied errors
+    if (!description) {
+        description =
+            lang === Lang.Ru
+                ? 'Произошла непредвиденная ошибка. Попробуйте обновить страницу через некоторое время.'
+                : 'An unexpected error has occurred. Try to refresh the page in a few moments.';
+    }
+    const status = getStatusByGrpcCode(error.code);
+    return {
+        status,
+        message: String(description || DEFAULT_GATEWAY_MESSAGE),
+        code: DEFAULT_GATEWAY_CODE,
+        details: Object.assign({ title,
+            description, grpcCode: code }, (typeof details === 'object' && !Array.isArray(details) ? details : { details })),
+    };
+}
+export class GrpcError extends Error {
+    constructor(message, parsedError, rawError) {
+        super(message);
+        this.parsedError = parsedError;
+        this.rawError = rawError;
+    }
+    getGatewayError() {
+        return this.parsedError;
+    }
+    getRawError() {
+        return this.rawError;
+    }
+    getAppError(ErrorConstructor) {
+        return new ErrorConstructor(this.parsedError.message, {
+            code: this.parsedError.code,
+            details: this.parsedError.details,
+            debug: this.parsedError.debug,
+        });
+    }
+}
+export function isGrpcError(error) {
+    return error.getGatewayError !== undefined;
+}
+export function grpcErrorFactory(error) {
+    return new GrpcError(error.message, {
+        status: 500,
+        code: '',
+        message: error.message,
+        details: {},
+    });
+}

package/dist/esm/utils/proto-path-resolver.d.ts

@@ -0,0 +1,2 @@
+import protobufjs from 'protobufjs';
+export declare function patchProtoPathResolver(root: protobufjs.Root, includeDirs: string[]): void;