@gravity-ui/gateway 4.1.2-alpha.0 → 4.2.1

package/dist/esm/index.js

@@ -1,264 +0,0 @@
-import _ from 'lodash';
-import { createGrpcAction, createRoot, getCredentialsMap } from './components/grpc.js';
-import { createMixedAction } from './components/mixed.js';
-import { createRestAction } from './components/rest.js';
-import { ANY_ACTION_SYMBOL } from './constants.js';
-import { getKeys, handleError } from './utils/common.js';
-import { overrideEndpoints } from './utils/overrideEndpoints/overrideEndpoints.js';
-export * from './utils/typed-api.js';
-export * from './utils/grpc-reflection.js';
-export * from './models/common.js';
-export * from './models/context.js';
-export * from './models/error.js';
-function isMixedActionConfig(actionConfig) {
-    return typeof actionConfig === 'function';
-}
-function isRestActionConfig(actionConfig) {
-    return Boolean(actionConfig.method);
-}
-function createApiAction(schema, config, serviceKey, actionName, api, grpcContext) {
-    var _a;
-    const serviceSchema = schema[serviceKey];
-    if (!serviceSchema) {
-        throw new config.ErrorConstructor(`Gateway config error. Service "${serviceKey}" have been not found.`, {
-            code: 'SERVICE_NOT_FOUND',
-        });
-    }
-    const action = serviceSchema.actions[actionName];
-    if (!action) {
-        throw new config.ErrorConstructor(`Gateway config error. Action "${serviceKey}.${actionName}" have been not found.`, {
-            code: 'ACTION_NOT_FOUND',
-        });
-    }
-    const serviceName = serviceSchema.serviceName || '';
-    const installation = config.installation || '';
-    const env = config.env || '';
-    if (isMixedActionConfig(action)) {
-        const resultServiceName = serviceName || serviceKey;
-        return createMixedAction(action, api, resultServiceName, actionName, { config, grpcContext }, config.ErrorConstructor);
-    }
-    const endpointsConfig = _.get(serviceSchema.endpoints, [installation, env]);
-    if (isRestActionConfig(action)) {
-        return createRestAction(endpointsConfig, action, serviceKey, actionName, {
-            serviceName,
-            timeout: config.timeout,
-            sendStats: config.sendStats,
-            proxyHeaders: config.proxyHeaders,
-            proxyDebugHeaders: config.proxyDebugHeaders,
-            axiosConfig: config.axiosConfig,
-            axiosInterceptors: config.axiosInterceptors,
-            validationSchema: config.validationSchema,
-            encodePathArgs: config.encodePathArgs,
-            getAuthHeaders: config.getAuthHeaders,
-        }, config.ErrorConstructor);
-    }
-    const grpcRecreateService = (_a = config.grpcRecreateService) !== null && _a !== void 0 ? _a : true;
-    return createGrpcAction(grpcContext, endpointsConfig, action, serviceKey, actionName, {
-        serviceName,
-        timeout: config.timeout,
-        sendStats: config.sendStats,
-        proxyHeaders: config.proxyHeaders,
-        proxyDebugHeaders: config.proxyDebugHeaders,
-        grpcOptions: config.grpcOptions,
-        grpcRecreateService,
-        getAuthHeaders: config.getAuthHeaders,
-    }, config.ErrorConstructor);
-}
-function generateGatewayApi(schema, config, grpcContext, baseApi) {
-    const { installation, env } = config;
-    if (!installation) {
-        throw new config.ErrorConstructor('Gateway config error', {
-            code: 'EMPTY_GATEWAY_INSTALLATION',
-        });
-    }
-    if (!env) {
-        throw new config.ErrorConstructor('Gateway config error', { code: 'EMPTY_GATEWAY_ENV' });
-    }
-    return Object.keys(schema).reduce((api, serviceKey) => {
-        return _.set(api, serviceKey, Object.keys(schema[serviceKey].actions).reduce((serviceActions, actionName) => (Object.assign(Object.assign({}, serviceActions), { [actionName]: createApiAction(schema, config, serviceKey, actionName, baseApi, grpcContext) })), {}));
-    }, {});
-}
-function generateGatewayApiController(schemasByScope, Api, config, controllerActions) {
-    // eslint-disable-next-line complexity
-    return async function gateway(req, res) {
-        var _a, _b, _c;
-        const { userId } = res.locals || {};
-        const { service, action, scope = 'root' } = req.params;
-        const withDebugHeaders = typeof config.withDebugHeaders === 'function'
-            ? config.withDebugHeaders(req, res)
-            : Boolean(config.withDebugHeaders);
-        const onUnknownAction = config === null || config === void 0 ? void 0 : config.onUnknownAction;
-        const onBeforeAction = config === null || config === void 0 ? void 0 : config.onBeforeAction;
-        const onRequestSuccess = config === null || config === void 0 ? void 0 : config.onRequestSuccess;
-        const onRequestFailed = config === null || config === void 0 ? void 0 : config.onRequestFailed;
-        if (!Api || !Api[scope] || !Api[scope][service]) {
-            if (onUnknownAction) {
-                return onUnknownAction(req, res, {
-                    service,
-                });
-            }
-            else {
-                return res.status(404).send({
-                    status: 404,
-                    code: 'UNKNOWN_SERVICE',
-                    message: 'Unknown service',
-                });
-            }
-        }
-        if (!Api[scope][service][action]) {
-            if (onUnknownAction) {
-                return onUnknownAction(req, res, {
-                    service,
-                    action,
-                });
-            }
-            else {
-                return res.status(404).send({
-                    status: 404,
-                    code: 'UNKNOWN_SERVICE_ACTION',
-                    message: 'Unknown service action',
-                });
-            }
-        }
-        // Validation of private endpoints, preventing their invocation through the controller.
-        if (_.startsWith(action, '_')) {
-            return res.status(404).send({
-                status: 404,
-                code: 'UNKNOWN_SERVICE_ACTION',
-                message: 'Unknown service action',
-            });
-        }
-        if (controllerActions &&
-            _.get(controllerActions, [scope]) !== ANY_ACTION_SYMBOL &&
-            _.get(controllerActions, [scope, service]) !== ANY_ACTION_SYMBOL &&
-            !_.get(controllerActions, [scope, service, action])) {
-            return res.status(404).send({
-                status: 404,
-                code: 'UNKNOWN_SERVICE_ACTION',
-                message: 'Unknown service action',
-            });
-        }
-        const args = req.method === 'GET' ? req.query : req.body;
-        try {
-            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];
-                try {
-                    await onBeforeAction(req, res, scope, service, action, actionConfig);
-                }
-                catch (error) {
-                    handleError(config.ErrorConstructor, error, req.ctx, 'Before action handler error');
-                    throw { error, debugHeaders: {} };
-                }
-            }
-            const { responseData, responseHeaders, debugHeaders } = await apiAction({
-                requestId: req.id,
-                headers: req.headers,
-                ctx: req.ctx,
-                args,
-                authArgs: config.getAuthArgs(req, res),
-                userId,
-            });
-            if (withDebugHeaders) {
-                res.set(debugHeaders);
-            }
-            if (responseHeaders) {
-                res.set(responseHeaders);
-            }
-            if (onRequestSuccess) {
-                return onRequestSuccess(req, res, responseData);
-            }
-            else {
-                return res.send(responseData);
-            }
-        }
-        catch (respError) {
-            const { error, debugHeaders } = respError;
-            let responseError = error;
-            if (withDebugHeaders) {
-                res.set(debugHeaders);
-            }
-            else {
-                responseError = _.omit(error, ['debug']);
-                // Remove DebugInfo
-                if (responseError.details) {
-                    _.forEach(responseError.details, function (value, key) {
-                        const DEBUG_INFO_TYPE = 'type.googleapis.com/google.rpc.DebugInfo';
-                        if ((value === null || value === void 0 ? void 0 : value['@type']) === DEBUG_INFO_TYPE) {
-                            responseError.details[key] = undefined;
-                        }
-                    });
-                }
-            }
-            if (onRequestFailed) {
-                return onRequestFailed(req, res, error);
-            }
-            else {
-                return res.status(_.get(error, 'status', 500)).send(responseError);
-            }
-        }
-    };
-}
-export function getGatewayControllers(schemasByScope, config) {
-    var _a;
-    const apiByScope = {};
-    config.installation = config.installation || process.env.APP_INSTALLATION;
-    config.env = config.env || process.env.APP_ENV;
-    if (process.env.GATEWAY_ENDPOINTS_OVERRIDES) {
-        try {
-            // eslint-disable-next-line no-param-reassign
-            schemasByScope = overrideEndpoints(schemasByScope, JSON.parse(process.env.GATEWAY_ENDPOINTS_OVERRIDES), config.installation, config.env);
-        }
-        catch (err) {
-            console.warn('Error when parse GATEWAY_ENDPOINTS_OVERRIDES', err);
-        }
-    }
-    const credentials = getCredentialsMap(config.caCertificatePath);
-    for (const scope of getKeys(schemasByScope)) {
-        apiByScope[scope] = generateGatewayApi(schemasByScope[scope], config, { root: createRoot(config.includeProtoRoots), credentials }, apiByScope);
-    }
-    const api = Object.assign({}, apiByScope);
-    const rootScope = apiByScope.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;
-        }
-    }
-    const controllerActions = config.actions
-        ? config.actions.reduce((acc, item) => {
-            const [scope, service, action] = item.split('.');
-            // Ignore option '*' for scopes
-            if (scope === ANY_ACTION_SYMBOL) {
-                return acc;
-            }
-            if (service === ANY_ACTION_SYMBOL) {
-                _.set(acc, [scope], ANY_ACTION_SYMBOL);
-            }
-            else if (action === ANY_ACTION_SYMBOL) {
-                if (acc[scope] !== ANY_ACTION_SYMBOL) {
-                    _.set(acc, [scope, service], ANY_ACTION_SYMBOL);
-                }
-            }
-            else {
-                _.set(acc, [scope, service, action], true);
-            }
-            return acc;
-        }, {})
-        : undefined;
-    const controller = generateGatewayApiController(schemasByScope, api, config, controllerActions);
-    return {
-        controller,
-        api,
-    };
-}
-export default getGatewayControllers;

package/dist/esm/models/common.js

@@ -1,5 +0,0 @@
-export var GrpcReflection;
-(function (GrpcReflection) {
-    GrpcReflection[GrpcReflection["OnFirstRequest"] = 0] = "OnFirstRequest";
-    GrpcReflection[GrpcReflection["OnEveryRequest"] = 1] = "OnEveryRequest";
-})(GrpcReflection || (GrpcReflection = {}));

package/dist/esm/models/context.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/models/error.d.ts

@@ -1,12 +0,0 @@
-export interface AppErrorArgs {
-    code?: string | number;
-    details?: object;
-    debug?: object;
-}
-export interface AppErrorWrapArgs extends AppErrorArgs {
-    message?: string;
-}
-export interface AppErrorConstructor {
-    new (message?: string, args?: AppErrorArgs): Error;
-    wrap: (error: Error, args?: AppErrorWrapArgs) => Error;
-}

package/dist/esm/models/error.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

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

@@ -1,3 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { AxiosInterceptorsConfig } from '../models/common.js';
-export declare function getAxiosClient(timeout?: number, retries?: number, axiosConfig?: AxiosRequestConfig, { request: reqInterceptors, response: resInterceptors }?: AxiosInterceptorsConfig): import("axios").AxiosInstance;

package/dist/esm/utils/axios.js

@@ -1,23 +0,0 @@
-import axios from 'axios';
-import axiosRetry from 'axios-retry';
-import _ from 'lodash';
-import { DEFAULT_AXIOS_OPTIONS, DEFAULT_TIMEOUT } from '../constants.js';
-export function getAxiosClient(timeout = DEFAULT_TIMEOUT, retries = 0, axiosConfig = DEFAULT_AXIOS_OPTIONS, { request: reqInterceptors, response: resInterceptors } = {}) {
-    const client = axios.create(Object.assign(Object.assign({}, axiosConfig), { timeout }));
-    reqInterceptors === null || reqInterceptors === void 0 ? void 0 : reqInterceptors.forEach(({ callback, errorCallback }) => client.interceptors.request.use(callback, errorCallback));
-    resInterceptors === null || resInterceptors === void 0 ? void 0 : resInterceptors.forEach(({ callback, errorCallback }) => client.interceptors.response.use(callback, errorCallback));
-    axiosRetry(client, {
-        retries,
-        retryDelay: axiosRetry.exponentialDelay,
-        retryCondition: (error) => {
-            if (!error.config) {
-                return false;
-            }
-            return axiosRetry.isNetworkError(error) || axiosRetry.isRetryableError(error);
-        },
-        onRetry: (retryCount, _error, requestConfig) => {
-            _.set(requestConfig, ['headers', 'x-request-attempt'], retryCount);
-        },
-    });
-    return client;
-}

package/dist/esm/utils/common.js

@@ -1,38 +0,0 @@
-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);
-    }
-}

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

@@ -1,4 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,72 +0,0 @@
-import _ from 'lodash';
-import * as 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

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

package/dist/esm/utils/grpc.js

@@ -1,39 +0,0 @@
-/* eslint-disable camelcase */
-import { DEFAULT_PROTO_LOADER_OPTIONS, RECREATE_SERVICE_CODES, RETRYABLE_STATUS_CODES, } from '../constants.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);
-    const type = root.lookupType(typeName);
-    const decodedMessage = type.toObject(type.decode(message.value), Object.assign(Object.assign({}, DEFAULT_PROTO_LOADER_OPTIONS), decodeAnyMessageProtoLoaderOptions));
-    return decodeAnyMessageRecursively(root, decodedMessage, decodeAnyMessageProtoLoaderOptions);
-}
-export function isRetryableError(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);
-}

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

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

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

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

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

@@ -1,17 +0,0 @@
-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;