@gravity-ui/gateway 1.0.2 → 1.0.4

package/build/components/grpc.d.ts

@@ -20,5 +20,5 @@ export interface GrpcContext {
 }
 export declare function createRoot(includeGrpcPaths?: string[]): protobufjs.Root;
 export declare function getCredentialsMap(caCertificatePath?: string | null): CredentialsMap;
-export default function createGrpcAction<Context extends GatewayContext>({ root, credentials }: GrpcContext, endpoints: EndpointsConfig | undefined, config: ApiServiceGrpcActionConfig<Context, any, any>, serviceKey: string, actionName: string, options: GatewayApiOptions<Context>, ErrorConctructor: AppErrorConstructor): (actionConfig: ApiActionConfig<Context, any, any>) => Promise<import("../models/common").GatewayActionClientStreamResponse<any> | import("../models/common").GatewayActionServerStreamResponse<any> | import("../models/common").GatewayActionDuplexStreamResponse<any> | import("../models/common").GatewayActionUnaryResponse<any>>;
+export default function createGrpcAction<Context extends GatewayContext>({ root, credentials }: GrpcContext, endpoints: EndpointsConfig | undefined, config: ApiServiceGrpcActionConfig<Context, any, any>, serviceKey: string, actionName: string, options: GatewayApiOptions<Context>, ErrorConstructor: AppErrorConstructor): (actionConfig: ApiActionConfig<Context, any, any>) => Promise<import("../models/common").GatewayActionClientStreamResponse<any> | import("../models/common").GatewayActionServerStreamResponse<any> | import("../models/common").GatewayActionDuplexStreamResponse<any> | import("../models/common").GatewayActionUnaryResponse<any>>;
 export {};

package/build/components/grpc.js

@@ -97,7 +97,7 @@ function getCredentialsMap(caCertificatePath) {
     };
 }
 exports.getCredentialsMap = getCredentialsMap;
-function decodeResponse(response, packageRoot, ctx, encodedFields = [], ErrorConctructor) {
+function decodeResponse(response, packageRoot, ctx, encodedFields = [], ErrorConstructor) {
     const systemFields = ['metadata', 'response', 'error.details'];
     [...systemFields, ...encodedFields].forEach((fieldName) => {
         try {
@@ -114,7 +114,7 @@ function decodeResponse(response, packageRoot, ctx, encodedFields = [], ErrorCon
             }
         }
         catch (error) {
-            (0, common_2.handleError)(ErrorConctructor, error, ctx, 'Message decoding failed', { fieldName });
+            (0, common_2.handleError)(ErrorConstructor, error, ctx, 'Message decoding failed', { fieldName });
         }
     });
 }
@@ -324,15 +324,15 @@ async function getServiceInstance(root, config, endpointData, grpcOptions, crede
     }
     return serviceInstance;
 }
-async function getResponseData({ config, response, ctx, packageRoot, args, ErrorConctructor, }) {
+async function getResponseData({ config, response, ctx, packageRoot, args, ErrorConstructor, }) {
     // Handle operation's runtime protocol buffers
     if (response) {
         const encodedFields = config.encodedFields;
         if (Array.isArray(response)) {
-            response.forEach((responseItem) => decodeResponse(responseItem, packageRoot, ctx, encodedFields, ErrorConctructor));
+            response.forEach((responseItem) => decodeResponse(responseItem, packageRoot, ctx, encodedFields, ErrorConstructor));
         }
         else if (typeof response === 'object') {
-            decodeResponse(response, packageRoot, ctx, encodedFields, ErrorConctructor);
+            decodeResponse(response, packageRoot, ctx, encodedFields, ErrorConstructor);
         }
     }
     let responseData = response;
@@ -345,12 +345,12 @@ async function getResponseData({ config, response, ctx, packageRoot, args, Error
             ctx.log('Transformed response data');
         }
         catch (error) {
-            (0, common_2.handleError)(ErrorConctructor, error, ctx, 'Transform response data failed');
+            (0, common_2.handleError)(ErrorConstructor, error, ctx, 'Transform response data failed');
         }
     }
     return responseData;
 }
-function createGrpcAction({ root, credentials }, endpoints, config, serviceKey, actionName, options, ErrorConctructor) {
+function createGrpcAction({ root, credentials }, endpoints, config, serviceKey, actionName, options, ErrorConstructor) {
     const serviceName = (options === null || options === void 0 ? void 0 : options.serviceName) || serviceKey;
     let getService;
     let recreateService;
@@ -450,7 +450,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             var _a;
             const restStatus = lodash_1.default.get(grpcError.getGatewayError(), 'status', 500);
             sendStats(restStatus, Object.assign(Object.assign({}, requestData), { responseSize: (_a = grpcError.getRawError()) === null || _a === void 0 ? void 0 : _a.metadata, grpcStatus: grpcError.getGatewayError().code }));
-            ctx.logError('Request failed', ErrorConctructor.wrap(grpcError.getAppError(ErrorConctructor)), Object.assign({ serviceName,
+            ctx.logError('Request failed', ErrorConstructor.wrap(grpcError.getAppError(ErrorConstructor)), Object.assign({ serviceName,
                 actionName, debugHeaders: (0, common_2.sanitizeDebugHeaders)(debugHeaders) }, grpcError.getGatewayError()));
             ctx.end();
         }
@@ -460,7 +460,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                 params = await config.params(args, headers, { ctx });
             }
             catch (error) {
-                (0, common_2.handleError)(ErrorConctructor, error, ctx, 'Getting config params failed');
+                (0, common_2.handleError)(ErrorConstructor, error, ctx, 'Getting config params failed');
             }
         }
         let service;
@@ -468,7 +468,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
             service = await getService(args);
         }
         catch (error) {
-            (0, common_2.handleError)(ErrorConctructor, error, ctx, 'getService failed');
+            (0, common_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
             throw error;
         }
         // eslint-disable-next-line complexity
@@ -619,7 +619,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                                     service = await getService(args);
                                 }
                                 catch (error) {
-                                    (0, common_2.handleError)(ErrorConctructor, error, ctx, 'getService failed');
+                                    (0, common_2.handleError)(ErrorConstructor, error, ctx, 'getService failed');
                                     throw error;
                                 }
                                 // Update service
@@ -637,7 +637,7 @@ function createGrpcAction({ root, credentials }, endpoints, config, serviceKey,
                                 config,
                                 args,
                                 packageRoot: root,
-                                ErrorConctructor,
+                                ErrorConstructor,
                             });
                             Object.assign(debugHeaders, (0, common_2.getHeadersFromMetadata)(trailingMetadata));
                             sendStats(200, Object.assign(Object.assign({}, requestData), { responseSize: (0, object_sizeof_1.default)(response), grpcStatus: 0 }));

package/build/components/mixed.d.ts

@@ -5,7 +5,7 @@ import type { GrpcContext } from './grpc';
 export declare function createMixedAction<TSchema extends SchemasByScope, Context extends GatewayContext, Req extends GatewayRequest<Context>, Res extends GatewayResponse>(config: ApiServiceMixedActionConfig<Context, Req, Res, any, any, any>, api: ApiByScope<TSchema, Context, Req, Res>, serviceName: string, actionName: string, extra: {
     config: GatewayConfig<Context, Req, Res>;
     grpcContext: GrpcContext;
-}, ErrorConctructor: AppErrorConstructor): (actionConfig: ApiActionConfig<Context, any>) => Promise<{
+}, ErrorConstructor: AppErrorConstructor): (actionConfig: ApiActionConfig<Context, any>) => Promise<{
     responseData: any;
     debugHeaders: {};
 }>;

package/build/components/mixed.js

@@ -16,7 +16,7 @@ const constants_1 = require("../constants");
 const common_1 = require("../utils/common");
 const create_context_api_1 = require("../utils/create-context-api");
 const parse_error_1 = require("../utils/parse-error");
-function createMixedAction(config, api, serviceName, actionName, extra, ErrorConctructor) {
+function createMixedAction(config, api, serviceName, actionName, extra, ErrorConstructor) {
     return async (actionConfig) => {
         const { args } = actionConfig, context = __rest(actionConfig, ["args"]);
         const ctx = actionConfig.ctx.create(`Gateway ${serviceName} ${actionName} [mixed]`, {
@@ -37,7 +37,7 @@ function createMixedAction(config, api, serviceName, actionName, extra, ErrorCon
         }
         catch (e) {
             if (e instanceof Object && 'error' in e) {
-                (0, common_1.handleError)(ErrorConctructor, e, ctx, 'Request failed', {
+                (0, common_1.handleError)(ErrorConstructor, e, ctx, 'Request failed', {
                     actionName,
                     serviceName,
                 });
@@ -45,7 +45,7 @@ function createMixedAction(config, api, serviceName, actionName, extra, ErrorCon
             }
             if (e instanceof Error) {
                 const parsedError = (0, parse_error_1.parseMixedError)(e);
-                ctx.logError('Request failed', ErrorConctructor.wrap(e), {
+                ctx.logError('Request failed', ErrorConstructor.wrap(e), {
                     actionName,
                     serviceName,
                     parsedError,

package/build/components/rest.d.ts

@@ -1,7 +1,7 @@
 import { ApiActionConfig, ApiServiceRestActionConfig, EndpointsConfig, GatewayApiOptions, Headers } from '../models/common';
 import { GatewayContext } from '../models/context';
 import { AppErrorConstructor } from '../models/error';
-export default function createRestAction<Context extends GatewayContext>(endpoints: EndpointsConfig | undefined, config: ApiServiceRestActionConfig<Context, any, any>, serviceKey: string, actionName: string, options: GatewayApiOptions<Context>, ErrorConctructor: AppErrorConstructor): (actionConfig: ApiActionConfig<Context, any>) => Promise<{
+export default function createRestAction<Context extends GatewayContext>(endpoints: EndpointsConfig | undefined, config: ApiServiceRestActionConfig<Context, any, any>, serviceKey: string, actionName: string, options: GatewayApiOptions<Context>, ErrorConstructor: AppErrorConstructor): (actionConfig: ApiActionConfig<Context, any>) => Promise<{
     responseData: unknown;
     debugHeaders: Headers;
 }>;

package/build/components/rest.js

@@ -13,14 +13,14 @@ const common_1 = require("../utils/common");
 const parse_error_1 = require("../utils/parse-error");
 const redact_sensitive_headers_1 = require("../utils/redact-sensitive-headers");
 const validate_1 = require("../utils/validate");
-function getRestResponseSize(data, ctx, ErrorConctructor) {
+function getRestResponseSize(data, ctx, ErrorConstructor) {
     var _a;
     let responseSize = 0;
     try {
         responseSize = constants_1.ECMA_STRING_SIZE * ((_a = JSON.stringify(data)) === null || _a === void 0 ? void 0 : _a.length);
     }
     catch (error) {
-        (0, common_1.handleError)(ErrorConctructor, error, ctx, 'Calculate response size failed');
+        (0, common_1.handleError)(ErrorConstructor, error, ctx, 'Calculate response size failed');
     }
     return responseSize;
 }
@@ -33,7 +33,7 @@ function getConfigSerializerFunction(config) {
     }
     return undefined;
 }
-function createRestAction(endpoints, config, serviceKey, actionName, options, ErrorConctructor) {
+function createRestAction(endpoints, config, serviceKey, actionName, options, ErrorConstructor) {
     var _a;
     const timeout = (_a = config === null || config === void 0 ? void 0 : config.timeout) !== null && _a !== void 0 ? _a : options === null || options === void 0 ? void 0 : options.timeout;
     const defaultAxiosClient = (0, axios_1.getAxiosClient)(timeout, config === null || config === void 0 ? void 0 : config.retries, options === null || options === void 0 ? void 0 : options.axiosConfig);
@@ -150,7 +150,7 @@ function createRestAction(endpoints, config, serviceKey, actionName, options, Er
                 params = await config.params(args, actionHeaders, { ctx });
             }
             catch (error) {
-                (0, common_1.handleError)(ErrorConctructor, error, ctx, 'Getting config params failed');
+                (0, common_1.handleError)(ErrorConstructor, error, ctx, 'Getting config params failed');
             }
         }
         const { body = undefined, query = undefined, headers = actionHeaders } = params !== null && params !== void 0 ? params : {};
@@ -171,7 +171,7 @@ function createRestAction(endpoints, config, serviceKey, actionName, options, Er
             }
         }
         catch (error) {
-            (0, common_1.handleError)(ErrorConctructor, error, ctx, 'Stringify request body failed');
+            (0, common_1.handleError)(ErrorConstructor, error, ctx, 'Stringify request body failed');
         }
         Object.assign(debugHeaders, {
             'x-api-request-method': config.method,
@@ -227,11 +227,11 @@ function createRestAction(endpoints, config, serviceKey, actionName, options, Er
                     ctx.log('Transformed response data');
                 }
                 catch (error) {
-                    (0, common_1.handleError)(ErrorConctructor, error, ctx, 'Transform response data failed');
+                    (0, common_1.handleError)(ErrorConstructor, error, ctx, 'Transform response data failed');
                 }
             }
             if (options === null || options === void 0 ? void 0 : options.sendStats) {
-                options.sendStats(Object.assign(Object.assign({}, requestData), { responseSize: getRestResponseSize(response === null || response === void 0 ? void 0 : response.data, ctx, ErrorConctructor), restStatus: 200 }), (0, redact_sensitive_headers_1.redactSensitiveHeaders)(parentCtx, headers), parentCtx, { debugHeaders: (0, common_1.sanitizeDebugHeaders)(debugHeaders) });
+                options.sendStats(Object.assign(Object.assign({}, requestData), { responseSize: getRestResponseSize(response === null || response === void 0 ? void 0 : response.data, ctx, ErrorConstructor), restStatus: 200 }), (0, redact_sensitive_headers_1.redactSensitiveHeaders)(parentCtx, headers), parentCtx, { debugHeaders: (0, common_1.sanitizeDebugHeaders)(debugHeaders) });
             }
             else {
                 ctx.stats(Object.assign(Object.assign({}, requestData), { responseStatus: 200 }));
@@ -256,7 +256,7 @@ function createRestAction(endpoints, config, serviceKey, actionName, options, Er
                     ctx.log('Transformed response error');
                 }
                 catch (error) {
-                    (0, common_1.handleError)(ErrorConctructor, error, ctx, 'Transform response error failed');
+                    (0, common_1.handleError)(ErrorConstructor, error, ctx, 'Transform response error failed');
                 }
             }
             if (!parsedError) {
@@ -264,12 +264,12 @@ function createRestAction(endpoints, config, serviceKey, actionName, options, Er
                     parsedError = (0, parse_error_1.parseRestError)(error, lang);
                 }
                 catch (error) {
-                    (0, common_1.handleError)(ErrorConctructor, error, ctx, 'Error parse rest error');
+                    (0, common_1.handleError)(ErrorConstructor, error, ctx, 'Error parse rest error');
                 }
             }
             const responseStatus = lodash_1.default.get(parsedError, 'status') || lodash_1.default.get(error, 'status', 500);
             if (options === null || options === void 0 ? void 0 : options.sendStats) {
-                options.sendStats(Object.assign(Object.assign({}, requestData), { responseSize: getRestResponseSize((_d = error === null || error === void 0 ? void 0 : error.response) === null || _d === void 0 ? void 0 : _d.data, ctx, ErrorConctructor), restStatus: responseStatus }), (0, redact_sensitive_headers_1.redactSensitiveHeaders)(parentCtx, headers), parentCtx, { debugHeaders: (0, common_1.sanitizeDebugHeaders)(debugHeaders) });
+                options.sendStats(Object.assign(Object.assign({}, requestData), { responseSize: getRestResponseSize((_d = error === null || error === void 0 ? void 0 : error.response) === null || _d === void 0 ? void 0 : _d.data, ctx, ErrorConstructor), restStatus: responseStatus }), (0, redact_sensitive_headers_1.redactSensitiveHeaders)(parentCtx, headers), parentCtx, { debugHeaders: (0, common_1.sanitizeDebugHeaders)(debugHeaders) });
             }
             else {
                 ctx.stats(Object.assign(Object.assign({}, requestData), { responseStatus }));

package/build/index.js

@@ -50,13 +50,13 @@ function isRestActionConfig(actionConfig) {
 function createApiAction(schema, config, serviceKey, actionName, api, grpcContext) {
     const serviceSchema = schema[serviceKey];
     if (!serviceSchema) {
-        throw new config.ErrorConctructor(`Gateway config error. Service "${serviceKey}" have been not found.`, {
+        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.ErrorConctructor(`Gateway config error. Action "${serviceKey}.${actionName}" have been not found.`, {
+        throw new config.ErrorConstructor(`Gateway config error. Action "${serviceKey}.${actionName}" have been not found.`, {
             code: 'ACTION_NOT_FOUND',
         });
     }
@@ -65,7 +65,7 @@ function createApiAction(schema, config, serviceKey, actionName, api, grpcContex
     const env = config.env || '';
     if (isMixedActionConfig(action)) {
         const resultServiceName = serviceName || serviceKey;
-        return (0, mixed_1.createMixedAction)(action, api, resultServiceName, actionName, { config, grpcContext }, config.ErrorConctructor);
+        return (0, mixed_1.createMixedAction)(action, api, resultServiceName, actionName, { config, grpcContext }, config.ErrorConstructor);
     }
     const endpointsConfig = lodash_1.default.get(serviceSchema.endpoints, [installation, env]);
     if (isRestActionConfig(action)) {
@@ -78,7 +78,7 @@ function createApiAction(schema, config, serviceKey, actionName, api, grpcContex
             validationSchema: config.validationSchema,
             encodePathArgs: config.encodePathArgs,
             getAuthHeaders: config.getAuthHeaders,
-        }, config.ErrorConctructor);
+        }, config.ErrorConstructor);
     }
     return (0, grpc_1.default)(grpcContext, endpointsConfig, action, serviceKey, actionName, {
         serviceName,
@@ -88,17 +88,17 @@ function createApiAction(schema, config, serviceKey, actionName, api, grpcContex
         grpcOptions: config.grpcOptions,
         grpcRecreateService: config.grpcRecreateService,
         getAuthHeaders: config.getAuthHeaders,
-    }, config.ErrorConctructor);
+    }, config.ErrorConstructor);
 }
 function generateGatewayApi(schema, config, grpcContext, baseApi) {
     const { installation, env } = config;
     if (!installation) {
-        throw new config.ErrorConctructor('Gateway config error', {
+        throw new config.ErrorConstructor('Gateway config error', {
             code: 'EMPTY_GATEWAY_INSTALLATION',
         });
     }
     if (!env) {
-        throw new config.ErrorConctructor('Gateway config error', { code: 'EMPTY_GATEWAY_ENV' });
+        throw new config.ErrorConstructor('Gateway config error', { code: 'EMPTY_GATEWAY_ENV' });
     }
     return Object.keys(schema).reduce((api, serviceKey) => {
         return lodash_1.default.set(api, serviceKey, Object.keys(schema[serviceKey].actions).reduce((serviceActions, actionName) => (Object.assign(Object.assign({}, serviceActions), { [actionName]: createApiAction(schema, config, serviceKey, actionName, baseApi, grpcContext) })), {}));
@@ -172,7 +172,7 @@ function generateGatewayApiController(schemasByScope, Api, config, controllerAct
                     await onBeforeAction(req, res, scope, service, action, actionConfig);
                 }
                 catch (error) {
-                    (0, common_1.handleError)(config.ErrorConctructor, error, req.ctx, 'Before action handler error');
+                    (0, common_1.handleError)(config.ErrorConstructor, error, req.ctx, 'Before action handler error');
                     throw { error, debugHeaders: {} };
                 }
             }

package/build/models/common.d.ts

@@ -236,6 +236,6 @@ export interface GatewayConfig<Context extends GatewayContext, Req extends Gatew
     encodePathArgs?: boolean;
     getAuthArgs: (req: Req, res: Res) => Record<string, unknown> | undefined;
     getAuthHeaders: GetAuthHeaders;
-    ErrorConctructor: AppErrorConstructor;
+    ErrorConstructor: AppErrorConstructor;
 }
 export {};

package/build/utils/common.d.ts

@@ -12,4 +12,4 @@ export declare function getKeys<T extends object>(obj: T): (keyof T)[];
  */
 export declare function sanitizeDebugHeaders(debugHeaders: Headers): _.Omit<Headers, "x-api-request-body">;
 export declare function getHeadersFromMetadata(metadata: Record<string, grpc.MetadataValue[]>): Record<string, string>;
-export declare function handleError<Context extends GatewayContext>(ErrorConctructor: AppErrorConstructor, error: unknown, ctx: Context, message: string, extra?: Dict): void;
+export declare function handleError<Context extends GatewayContext>(ErrorConstructor: AppErrorConstructor, error: unknown, ctx: Context, message: string, extra?: Dict): void;

package/build/utils/common.js

@@ -39,9 +39,9 @@ function getHeadersFromMetadata(metadata) {
     }, {});
 }
 exports.getHeadersFromMetadata = getHeadersFromMetadata;
-function handleError(ErrorConctructor, error, ctx, message, extra) {
+function handleError(ErrorConstructor, error, ctx, message, extra) {
     if (error instanceof Error) {
-        ctx.logError(message, ErrorConctructor.wrap(error), extra);
+        ctx.logError(message, ErrorConstructor.wrap(error), extra);
     }
     else {
         ctx.logError(message, JSON.stringify(error), extra);

package/build/utils/parse-error.d.ts

@@ -26,7 +26,7 @@ export declare class GrpcError extends Error {
     constructor(message: string, parsedError: GatewayError, rawError?: grpc.ServiceError);
     getGatewayError(): GatewayError;
     getRawError(): grpc.ServiceError | undefined;
-    getAppError(ErrorConctructor: AppErrorConstructor): Error;
+    getAppError(ErrorConstructor: AppErrorConstructor): Error;
 }
 export declare function isGrpcError(error: Error | GrpcError): error is GrpcError;
 export declare function grpcErrorFactory(error: Error): GrpcError;

package/build/utils/parse-error.js

@@ -200,8 +200,8 @@ class GrpcError extends Error {
     getRawError() {
         return this.rawError;
     }
-    getAppError(ErrorConctructor) {
-        return new ErrorConctructor(this.parsedError.message, {
+    getAppError(ErrorConstructor) {
+        return new ErrorConstructor(this.parsedError.message, {
             code: this.parsedError.code,
             details: this.parsedError.details,
             debug: this.parsedError.debug,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/gateway",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "",
   "license": "MIT",
   "main": "build/index.js",
@@ -10,6 +10,7 @@
     "bin",
     "patches"
   ],
+  "types": "build/index.d.ts",
   "bin": {
     "gateway-reflection-patch": "bin/patch.js"
   },