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

package/dist/esm/index.js

@@ -0,0 +1,274 @@
+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 { isRetryableGrpcError } from './utils/grpc.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,
+            axiosRetryCondition: config.axiosRetryCondition,
+            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,
+        grpcRetryCondition: config.grpcRetryCondition,
+        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 abortController = new AbortController();
+            const handleCloseConnection = () => {
+                abortController.abort();
+            };
+            req.connection.once('close', handleCloseConnection);
+            const apiAction = Api[scope][service][action];
+            if (onBeforeAction) {
+                const actionConfig = (_c = (_b = (_a = schemasByScope[scope]) === null || _a === void 0 ? void 0 : _a[service]) === null || _b === void 0 ? void 0 : _b.actions) === null || _c === void 0 ? void 0 : _c[action];
+                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,
+                abortSignal: abortController.signal,
+            });
+            req.connection.removeListener('close', handleCloseConnection);
+            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.d.ts

@@ -0,0 +1,289 @@
+import { IncomingHttpHeaders } from 'http';
+import { ClientDuplexStream, ClientReadableStream, ClientWritableStream, type ServiceError } from '@grpc/grpc-js';
+import type { HandlerType } from '@grpc/grpc-js/build/src/server-call.js';
+import { AxiosInterceptorManager, AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+import { IAxiosRetryConfig } from 'axios-retry';
+import type { Request, Response } from 'express';
+import protobufjs from 'protobufjs';
+import type { GrpcContext } from '../components/grpc.js';
+import { Lang } from '../constants.js';
+import { GatewayContext } from './context.js';
+import { AppErrorConstructor } from './error.js';
+export interface GatewayRequest<Context extends GatewayContext> extends Request {
+    id: string;
+    ctx: Context;
+}
+export interface GatewayResponse extends Response {
+}
+export interface Headers {
+    [key: string]: any;
+}
+export interface EndpointsConfig {
+    [key: string]: ActionEndpoint;
+}
+export type AuthHeadersFunc = (serviceName: string) => Record<string, string> | undefined;
+export interface ApiActionConfig<Context extends GatewayContext, TRequestData, TResponseData = any> {
+    requestId: string;
+    headers: Headers;
+    args: TRequestData;
+    ctx: Context;
+    timeout?: number;
+    callback?: (response: TResponseData) => void;
+    authArgs?: Record<string, unknown>;
+    userId?: string;
+    abortSignal?: AbortSignal;
+}
+export interface GRPCActionData {
+    [key: string]: unknown;
+}
+export type SendStats<Context extends GatewayContext> = (stats: Stats, headers: IncomingHttpHeaders, ctx: Context, meta: {
+    debugHeaders: Headers;
+}) => void;
+export interface Stats {
+    service: string;
+    action: string;
+    restStatus: number;
+    grpcStatus?: number;
+    responseSize: number;
+    requestId: string;
+    requestTime: number;
+    requestMethod: string;
+    requestUrl: string;
+    timestamp: number;
+    userId?: string;
+    traceId: string;
+}
+export type ControllerType = 'rest' | 'grpc';
+export interface GatewayError {
+    status: number;
+    message: string;
+    code: string;
+    details?: {
+        title?: string;
+        description?: string;
+    } & Record<string, unknown>;
+    debug?: any;
+    requestId?: string;
+}
+export type GrpcRetryCondition = (error: ServiceError) => boolean;
+export type AxiosRetryCondition = IAxiosRetryConfig['retryCondition'];
+export type ProxyHeadersFunctionExtra = {
+    service: string;
+    action: string;
+    protopath?: string;
+    protokey?: string;
+};
+export type ProxyHeadersFunction = (headers: IncomingHttpHeaders, type: ControllerType, extra: ProxyHeadersFunctionExtra) => IncomingHttpHeaders;
+export type ProxyHeaders = string[] | ProxyHeadersFunction;
+export type ProxyResponseHeadersFunction = (headers: Headers, type: ControllerType) => Headers;
+export type ProxyResponseHeaders = string[] | ProxyResponseHeadersFunction;
+export type GetAuthHeadersParams<AuthArgs = Record<string, unknown>> = {
+    actionType: ControllerType;
+    serviceName: string;
+    requestHeaders: Headers;
+    authArgs: AuthArgs | undefined;
+};
+export type GetAuthHeaders<AuthArgs = Record<string, unknown>> = (params: GetAuthHeadersParams<AuthArgs>) => Record<string, string> | undefined;
+export type ResponseContentType = AxiosResponse['headers']['Content-Type'];
+export interface GatewayApiOptions<Context extends GatewayContext> {
+    serviceName: string;
+    timeout?: number;
+    grpcRetryCondition?: GrpcRetryCondition;
+    axiosRetryCondition?: AxiosRetryCondition;
+    sendStats?: SendStats<Context>;
+    grpcOptions?: object;
+    grpcRecreateService?: boolean;
+    axiosConfig?: AxiosRequestConfig;
+    axiosInterceptors?: AxiosInterceptorsConfig;
+    proxyHeaders?: ProxyHeaders;
+    proxyDebugHeaders?: ProxyHeaders;
+    validationSchema?: object;
+    encodePathArgs?: boolean;
+    expectedResponseContentType?: ResponseContentType | ResponseContentType[];
+    getAuthHeaders: GetAuthHeaders;
+}
+export interface ParamsOutput {
+    body?: any;
+    query?: {
+        [key: string]: any;
+    };
+    headers?: Headers;
+}
+export interface ResponseError extends AxiosResponse<unknown> {
+}
+export interface ExtendedBaseActionEndpoint {
+    path: string;
+}
+export interface ExtendedGrpcActionEndpoint extends ExtendedBaseActionEndpoint {
+    insecure?: boolean;
+    secureWithoutRootCert?: boolean;
+    grpcOptions?: object;
+}
+export interface ExtendedRestActionEndpoint extends ExtendedBaseActionEndpoint {
+    axiosConfig?: AxiosRequestConfig;
+}
+export type ExtendedActionEndpoint = ExtendedGrpcActionEndpoint | ExtendedRestActionEndpoint;
+export type ActionEndpoint = string | ExtendedActionEndpoint;
+export interface ApiServiceBaseActionConfig<Context extends GatewayContext, TOutput, TParams = undefined, TTransformed = TOutput> {
+    getAuthHeaders?: GetAuthHeaders;
+    params?: (args: TParams, headers: Headers, config: ApiParamsConfig<Context>) => Promise<ParamsOutput> | ParamsOutput;
+    endpoint?: string | ((endpoints: EndpointsConfig | undefined, args: TParams) => string);
+    transformResponseData?: (data: TOutput, config: ApiTransformResponseDataConfig<TParams, Context>) => Promise<TTransformed> | TTransformed;
+    transformResponseError?: (error: ResponseError, config: ApiTransformResponseErrorConfig<TParams, Context>) => Promise<GatewayError> | GatewayError;
+    validationSchema?: object;
+    timeout?: number;
+    retries?: number;
+    idempotency?: boolean;
+    proxyHeaders?: ProxyHeaders;
+    proxyResponseHeaders?: ProxyResponseHeaders;
+    metadata?: Record<string, string | number | boolean>;
+    abortOnClientDisconnect?: boolean;
+}
+export interface ApiServiceRestActionConfig<Context extends GatewayContext, TOutput, TParams = undefined, TTransformed = TOutput> extends ApiServiceBaseActionConfig<Context, TOutput, TParams, TTransformed> {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    path: (args: TParams) => string;
+    paramsSerializer?: AxiosRequestConfig['paramsSerializer'];
+    responseType?: AxiosRequestConfig['responseType'];
+    expectedResponseContentType?: ResponseContentType | ResponseContentType[];
+    maxRedirects?: number;
+    axiosRetryCondition?: AxiosRetryCondition;
+}
+export interface ApiServiceBaseGrpcActionConfig<Context extends GatewayContext, TOutput, TParams = undefined, TTransformed = TOutput> extends ApiServiceBaseActionConfig<Context, TOutput, TParams, TTransformed> {
+    action: string;
+    protoKey: string;
+    insecure?: boolean;
+    secureWithoutRootCert?: boolean;
+    encodedFields?: string[];
+    type?: HandlerType;
+    decodeAnyMessageProtoLoaderOptions?: protobufjs.IConversionOptions;
+}
+export interface ApiServiceFileGrpcActionConfig<Context extends GatewayContext, TOutput, TParams, TTransformed> extends ApiServiceBaseGrpcActionConfig<Context, TOutput, TParams, TTransformed> {
+    protoPath: string;
+}
+export declare enum GrpcReflection {
+    OnFirstRequest = 0,
+    OnEveryRequest = 1
+}
+export interface ApiServiceReflectGrpcActionConfig<Context extends GatewayContext, TOutput, TParams, TTransformed> extends ApiServiceBaseGrpcActionConfig<Context, TOutput, TParams, TTransformed> {
+    reflection: GrpcReflection;
+    reflectionRefreshSec?: number;
+}
+export type ApiServiceGrpcActionConfig<Context extends GatewayContext, TOutput, TParams = undefined, TTransformed = TOutput> = ApiServiceFileGrpcActionConfig<Context, TOutput, TParams, TTransformed> | ApiServiceReflectGrpcActionConfig<Context, TOutput, TParams, TTransformed>;
+export interface ApiServiceMixedExtra<Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse> {
+    headers: Headers;
+    lang: Lang;
+    ctx: Context;
+    config: GatewayConfig<Context, Req, Res>;
+    grpcContext: GrpcContext;
+    abortSignal?: AbortSignal;
+}
+export type ApiServiceMixedActionConfig<Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse, TOutput, TParams = undefined, TTransformed = TOutput> = (api: unknown, args: TParams, extra: ApiServiceMixedExtra<Context, Req, Res>) => Promise<TTransformed>;
+export type ApiServiceActionConfig<Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse, TOutput, TParams = undefined, TTransformed = TOutput> = ApiServiceRestActionConfig<Context, TOutput, TParams, TTransformed> | ApiServiceGrpcActionConfig<Context, TOutput, TParams, TTransformed> | ApiServiceMixedActionConfig<Context, Req, Res, TOutput, TParams, TTransformed>;
+export type ApiActionResponseType<T> = T extends ApiServiceActionConfig<any, any, any, any, any, infer R> ? R : never;
+export type ApiActionParams<T> = T extends ApiServiceActionConfig<any, any, any, any, infer R, any> ? R : never;
+export interface ApiParamsConfig<Context extends GatewayContext> {
+    ctx: Context;
+}
+export interface ApiTransformResponseDataConfig<TParams, Context extends GatewayContext> {
+    args: TParams;
+    ctx: Context;
+    headers?: Headers;
+}
+export interface ApiTransformResponseErrorConfig<TParams, Context extends GatewayContext> {
+    args: TParams;
+    ctx: Context;
+}
+export interface BaseSchema {
+    [key: string]: {
+        actions: Record<string, ApiServiceActionConfig<any, any, any, any, any, any>>;
+        serviceName?: string;
+        endpoints?: Record<string, Record<string, EndpointsConfig>>;
+    };
+}
+export interface SchemasByScope {
+    [scope: string]: BaseSchema;
+}
+export type ApiByScope<R extends SchemasByScope, Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse> = {
+    [scope in keyof R]: GatewayApi<R[scope], Context, Req, Res>;
+};
+export type ApiWithRoot<R extends SchemasByScope, Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse> = ApiByScope<R, Context, Req, Res>['root'] & ApiByScope<R, Context, Req, Res>;
+export interface GatewayActionHeaders {
+    debugHeaders: Headers;
+}
+export interface GatewayActionUnaryResponse<TAction> extends GatewayActionHeaders {
+    responseData: ApiActionResponseType<TAction>;
+    responseHeaders?: Headers;
+}
+export interface GatewayActionClientStreamResponse<TAction> extends GatewayActionHeaders {
+    stream: ClientWritableStream<ApiActionResponseType<TAction>>;
+    responseData?: never;
+    responseHeaders?: never;
+}
+export interface GatewayActionServerStreamResponse<TAction> extends GatewayActionHeaders {
+    stream: ClientReadableStream<ApiActionResponseType<TAction>>;
+    responseData?: never;
+    responseHeaders?: never;
+}
+export interface GatewayActionDuplexStreamResponse<TAction> extends GatewayActionHeaders {
+    stream: ClientDuplexStream<ApiActionParams<TAction>, ApiActionResponseType<TAction>>;
+    responseData?: never;
+    responseHeaders?: never;
+}
+export type GatewayActionResponseData<Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse, TAction extends ApiServiceActionConfig<Context, Req, Res, unknown, unknown, unknown>> = TAction extends ApiServiceGrpcActionConfig<Context, unknown, unknown, unknown> ? TAction['type'] extends 'clientStream' ? GatewayActionClientStreamResponse<TAction> : TAction['type'] extends 'serverStream' ? GatewayActionServerStreamResponse<TAction> : TAction['type'] extends 'bidi' ? GatewayActionDuplexStreamResponse<TAction> : GatewayActionUnaryResponse<TAction> : GatewayActionUnaryResponse<TAction>;
+type GatewayAction<Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse, TAction extends ApiServiceActionConfig<Context, Req, Res, unknown, unknown, unknown>> = undefined extends ApiActionParams<TAction> ? (params?: ApiActionConfig<Context, ApiActionParams<TAction>, ApiActionResponseType<TAction>>) => Promise<GatewayActionResponseData<Context, Req, Res, TAction>> : (params: ApiActionConfig<Context, ApiActionParams<TAction>, ApiActionResponseType<TAction>>) => Promise<GatewayActionResponseData<Context, Req, Res, TAction>>;
+export type GatewayApi<T extends BaseSchema, Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse> = {
+    [S in keyof T]: {
+        [A in keyof T[S]['actions']]: GatewayAction<Context, Req, Res, T[S]['actions'][A]>;
+    };
+};
+type ContextAction<TAction> = undefined extends ApiActionParams<TAction> ? (params?: ApiActionParams<TAction>) => Promise<ApiActionResponseType<TAction>> : (params: ApiActionParams<TAction>) => Promise<ApiActionResponseType<TAction>>;
+export type ContextApi<T extends BaseSchema> = {
+    [S in keyof T]: {
+        [A in keyof T[S]['actions']]: ContextAction<T[S]['actions'][A]>;
+    };
+};
+export type ContextApiByScope<R extends SchemasByScope> = {
+    [scope in keyof R]: ContextApi<R[scope]>;
+};
+export type ContextApiWithRoot<R extends SchemasByScope> = ContextApiByScope<R>['root'] & ContextApiByScope<R>;
+interface OnUnknownActionData {
+    service?: string;
+    action?: string;
+}
+type AxiosInterceptorUseParams<T> = Parameters<AxiosInterceptorManager<T>['use']>;
+interface AxiosInterceptorConfig<T> {
+    callback: AxiosInterceptorUseParams<T>[0];
+    errorCallback?: AxiosInterceptorUseParams<T>[1];
+}
+export interface AxiosInterceptorsConfig {
+    request?: AxiosInterceptorConfig<InternalAxiosRequestConfig<any>>[];
+    response?: AxiosInterceptorConfig<AxiosResponse<any>>[];
+}
+export interface GatewayConfig<Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse> {
+    installation?: string;
+    env?: string;
+    actions?: string[];
+    timeout?: number;
+    grpcRetryCondition?: GrpcRetryCondition;
+    axiosRetryCondition?: AxiosRetryCondition;
+    grpcOptions?: object;
+    grpcRecreateService?: boolean;
+    axiosConfig?: AxiosRequestConfig;
+    axiosInterceptors?: AxiosInterceptorsConfig;
+    onUnknownAction?: (req: Req, res: Res, data: OnUnknownActionData) => any;
+    onBeforeAction?: (req: Req, res: Res, scope: string, service: string, action: string, config?: ApiServiceActionConfig<Context, Req, Res, unknown>) => any;
+    onRequestSuccess?: (req: Req, res: Res, data: any) => any;
+    onRequestFailed?: (req: Req, res: Res, error: any) => any;
+    sendStats?: SendStats<Context>;
+    includeProtoRoots?: string[];
+    caCertificatePath: string | null;
+    proxyHeaders: ProxyHeaders;
+    proxyDebugHeaders?: ProxyHeaders;
+    withDebugHeaders?: boolean | ((req: Req, res: Res) => boolean);
+    validationSchema?: object;
+    encodePathArgs?: boolean;
+    getAuthArgs: (req: Req, res: Res) => Record<string, unknown> | undefined;
+    getAuthHeaders: GetAuthHeaders;
+    ErrorConstructor: AppErrorConstructor;
+}
+export {};

package/dist/esm/models/common.js

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

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

@@ -0,0 +1,22 @@
+import { IncomingHttpHeaders } from 'http';
+export interface GatewayContextParams {
+    tags?: Record<string, string | number | boolean | undefined>;
+}
+export type Dict = {
+    [key: string]: unknown;
+};
+export interface GatewayContext {
+    create: (name: string, params?: GatewayContextParams) => this;
+    log: (message: string, extra?: Dict) => void;
+    logError: (message: string, error?: unknown, extra?: Dict) => void;
+    end: () => void;
+    stats: (data: {
+        [name: string]: string | number;
+    }) => void;
+    utils?: {
+        redactSensitiveHeaders?: (headers?: IncomingHttpHeaders) => IncomingHttpHeaders;
+        redactSensitiveKeys?: (headers: Dict) => Dict;
+    };
+    getMetadata: () => IncomingHttpHeaders;
+    getTraceId?: () => string | undefined;
+}

package/dist/esm/models/context.js

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

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

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

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

package/dist/esm/package.json

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

package/{build → dist/esm}/utils/axios.d.ts

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

package/dist/esm/utils/axios.js

@@ -0,0 +1,24 @@
+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, customRetryCondition, 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) => {
+            var _a;
+            if (!error.config) {
+                return false;
+            }
+            return ((_a = customRetryCondition === null || customRetryCondition === void 0 ? void 0 : customRetryCondition(error)) !== null && _a !== void 0 ? _a : (axiosRetry.isNetworkError(error) || axiosRetry.isRetryableError(error)));
+        },
+        onRetry: (retryCount, _error, requestConfig) => {
+            _.set(requestConfig, ['headers', 'x-request-attempt'], retryCount);
+        },
+    });
+    return client;
+}

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

@@ -0,0 +1,16 @@
+import * as grpc from '@grpc/grpc-js';
+import _ from 'lodash';
+import { ActionEndpoint, ApiServiceGrpcActionConfig, ExtendedActionEndpoint, ExtendedGrpcActionEndpoint, ExtendedRestActionEndpoint, Headers, ProxyHeadersFunctionExtra } from '../models/common.js';
+import { Dict, GatewayContext } from '../models/context.js';
+import { AppErrorConstructor } from '../models/error.js';
+export declare function isExtendedActionEndpoint(endpoint: ActionEndpoint): endpoint is ExtendedActionEndpoint;
+export declare function isExtendedGrpcActionEndpoint(endpoint: ActionEndpoint): endpoint is ExtendedGrpcActionEndpoint;
+export declare function isExtendedRestActionEndpoint(endpoint: ActionEndpoint): endpoint is ExtendedRestActionEndpoint;
+export declare function getKeys<T extends object>(obj: T): (keyof T)[];
+/**
+ * This function should only use to sanitize debugHeaders that are creating in our code
+ */
+export declare function sanitizeDebugHeaders(debugHeaders: Headers): _.Omit<Headers, "x-api-request-body">;
+export declare function getHeadersFromMetadata(metadata: Record<string, grpc.MetadataValue[]>, prefix?: string): Record<string, string>;
+export declare function handleError<Context extends GatewayContext>(ErrorConstructor: AppErrorConstructor, error: unknown, ctx: Context, message: string, extra?: Dict): void;
+export declare const getProxyHeadersArgs: <Context extends GatewayContext>(serviceName: string, actionName: string, grpcConfig?: ApiServiceGrpcActionConfig<Context, any, any>) => ProxyHeadersFunctionExtra;