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

package/dist/esm/utils/common.js

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

@@ -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,68 @@
+import _ from 'lodash';
+import * as protobufjs from 'protobufjs';
+import { patchProtoPathResolver } from './proto-path-resolver.js';
+const reflectionClientsMap = {};
+function getCachedClient(actionEndpoint, credentials, grpcOptions, descriptorExtensionProto) {
+    const cacheKey = [actionEndpoint, JSON.stringify([grpcOptions, descriptorExtensionProto])];
+    let clientWithCache = _.get(reflectionClientsMap, cacheKey);
+    if (!clientWithCache) {
+        const grpcReflection = require('grpc-reflection-js');
+        let descriptorRoot;
+        if (descriptorExtensionProto) {
+            descriptorRoot = protobufjs.Root.fromJSON(require('protobufjs/ext/descriptor'));
+            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, 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 } = 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 } = 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,5 @@
+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

@@ -0,0 +1,39 @@
+/* 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

@@ -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/parse-error.d.ts

@@ -0,0 +1,30 @@
+import * as grpc from '@grpc/grpc-js';
+import * as 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,210 @@
+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 {
+            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 * as protobufjs from 'protobufjs';
+export declare function patchProtoPathResolver(root: protobufjs.Root, includeDirs: string[]): void;

package/dist/esm/utils/proto-path-resolver.js

@@ -0,0 +1,23 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as protobufjs from 'protobufjs';
+export function patchProtoPathResolver(root, includeDirs) {
+    const originalResolvePath = root.resolvePath;
+    root.resolvePath = function (origin, target) {
+        if (target in protobufjs.common || path.isAbsolute(target)) {
+            return target;
+        }
+        for (let i = 0; i < includeDirs.length; i++) {
+            const directory = includeDirs[i];
+            const fullPath = path.join(directory, target);
+            try {
+                fs.accessSync(fullPath, fs.constants.R_OK);
+                return fullPath;
+            }
+            catch (err) {
+                continue;
+            }
+        }
+        return originalResolvePath(origin, target);
+    };
+}

package/dist/esm/utils/redact-sensitive-headers.d.ts

@@ -0,0 +1,3 @@
+import { IncomingHttpHeaders } from 'http';
+import { GatewayContext } from '../models/context.js';
+export declare function redactSensitiveHeaders(ctx: GatewayContext, headers: IncomingHttpHeaders): IncomingHttpHeaders;

package/dist/esm/utils/redact-sensitive-headers.js

@@ -0,0 +1,12 @@
+export function redactSensitiveHeaders(ctx, headers) {
+    var _a, _b;
+    if ((_a = ctx.utils) === null || _a === void 0 ? void 0 : _a.redactSensitiveHeaders) {
+        return ctx.utils.redactSensitiveHeaders(headers);
+    }
+    else if ((_b = ctx.utils) === null || _b === void 0 ? void 0 : _b.redactSensitiveKeys) {
+        return ctx.utils.redactSensitiveKeys(headers);
+    }
+    else {
+        return headers;
+    }
+}

package/dist/esm/utils/source-dir.d.ts

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

package/dist/esm/utils/source-dir.js

@@ -0,0 +1,4 @@
+import * as path from 'path';
+import * as url from 'url';
+// @ts-ignore to get the CommonJS build to ignore it
+export const sourceDir = path.resolve(url.fileURLToPath(new URL('.', import.meta.url)), '..');

package/dist/esm/utils/typed-api.d.ts

@@ -0,0 +1,2 @@
+import { ContextApiWithRoot, SchemasByScope } from '../models/common.js';
+export declare function getTypedApiFactory<TSchema extends SchemasByScope>(): (api: unknown) => ContextApiWithRoot<TSchema>;

package/dist/esm/utils/typed-api.js

@@ -0,0 +1,3 @@
+export function getTypedApiFactory() {
+    return (api) => api;
+}

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

@@ -0,0 +1,4 @@
+export declare function validateArgs<TParams>(args: TParams, schema: object): string | false;
+export declare function encodePathParams<TParams extends {}>(params: TParams): Record<string, any>;
+export declare function getPathParam(value: string): string;
+export declare function getPathArgsProxy<TParams extends {}>(args: TParams, encodePathArgs?: boolean): TParams;