@gravity-ui/gateway 1.0.0

package/build/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;

package/build/utils/validate.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPathArgsProxy = exports.getPathParam = exports.encodePathParams = exports.validateArgs = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+function validateArgs(args, schema) {
+    const ajv = new ajv_1.default();
+    const validate = ajv.compile(schema);
+    return validate(args) ? false : ajv.errorsText(validate.errors);
+}
+exports.validateArgs = validateArgs;
+function encodePathParams(params) {
+    const encodedParams = {};
+    Object.keys(params).forEach((key) => {
+        const value = params[key];
+        if (value instanceof Buffer) {
+            encodedParams[key] = value;
+        }
+        else if (typeof value === 'object' && value !== null) {
+            encodedParams[key] = encodePathParams(value);
+        }
+        else {
+            encodedParams[key] = encodeURIComponent(value);
+        }
+    });
+    return encodedParams;
+}
+exports.encodePathParams = encodePathParams;
+function getPathParam(value) {
+    return /^((?!(\.\.|\?|#|\\|\/)).)*$/i.test(value) ? value : '';
+}
+exports.getPathParam = getPathParam;
+function getPathArgsProxy(args, encodePathArgs) {
+    if (!args) {
+        return args;
+    }
+    return new Proxy(args, {
+        get: (object, key) => {
+            const value = object[key];
+            if (value instanceof Buffer) {
+                return value;
+            }
+            if (typeof value === 'object' && value !== null) {
+                return getPathArgsProxy(value);
+            }
+            if (typeof value === 'string') {
+                const pathParam = getPathParam(value);
+                return encodePathArgs ? encodeURIComponent(pathParam) : pathParam;
+            }
+            return value; // TODO return error INVALID_PARAMS
+        },
+    });
+}
+exports.getPathArgsProxy = getPathArgsProxy;

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@gravity-ui/gateway",
+  "version": "1.0.0",
+  "description": "",
+  "license": "MIT",
+  "main": "build/index.js",
+  "files": [
+    "build",
+    "proto",
+    "bin",
+    "patches"
+  ],
+  "bin": {
+    "gateway-reflection-patch": "bin/patch.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gravity-ui/gateway.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gravity-ui/gateway/issues"
+  },
+  "homepage": "https://github.com/gravity-ui/gateway#readme",
+  "scripts": {
+    "prepare": "husky install",
+    "build": "tsc",
+    "build-integration": "sh integration-test/build.sh",
+    "start-integration-server": "node build-integration/integration-test/server",
+    "build-and-run-integration": "npm run build-integration && npm run start-integration-server",
+    "clean": "rm -rf build && rm -rf build-integration",
+    "lint": "eslint \"lib/**/*.{js,ts}\" --quiet",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "test": "jest --colors",
+    "test-integration": "npx patch-package && start-server-and-test build-and-run-integration http://127.0.0.1:3000 test-integration-no-server",
+    "test-integration-no-server": "jest --colors --config=jest.config-integration.js"
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.8.12",
+    "@grpc/proto-loader": "^0.6.13",
+    "ajv": "^8.12.0",
+    "axios": "^1.3.5",
+    "axios-retry": "^3.4.0",
+    "lodash": "^4.17.21",
+    "object-sizeof": "^2.6.1",
+    "protobufjs": "^6.11.4",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^17.7.1",
+    "@commitlint/config-conventional": "^17.7.0",
+    "@gravity-ui/eslint-config": "^2.0.0",
+    "@gravity-ui/prettier-config": "^1.0.1",
+    "@gravity-ui/tsconfig": "^1.0.0",
+    "@types/express": "^4.17.17",
+    "@types/jest": "^29.5.0",
+    "@types/lodash": "^4.14.192",
+    "@types/node": "^18.15.11",
+    "@types/uuid": "^9.0.1",
+    "axios-mock-adapter": "^1.21.2",
+    "eslint": "^8.44.0",
+    "eslint-plugin-import": "^2.27.5",
+    "grpc-reflection-js": "^0.1.2",
+    "grpc-server-reflection": "^0.1.5",
+    "grpc-tools": "^1.12.4",
+    "husky": "^8.0.3",
+    "jest": "^29.5.0",
+    "nano-staged": "^0.8.0",
+    "prettier": "^2.8.6",
+    "start-server-and-test": "^2.0.0",
+    "ts-jest": "^29.1.1",
+    "tsc-watch": "^6.0.0",
+    "typescript": "^5.0.2"
+  },
+  "peerDependencies": {
+    "grpc-reflection-js": "^0.1.2"
+  },
+  "peerDependenciesMeta": {
+    "grpc-reflection-js": {
+      "optional": true
+    }
+  },
+  "nano-staged": {
+    "*.{js,jsx,ts,tsx}": [
+      "eslint --fix --quiet"
+    ],
+    "*.md": [
+      "prettier --write"
+    ]
+  }
+}

package/patches/grpc-reflection-js+0.1.2.patch

@@ -0,0 +1,87 @@
+diff --git a/node_modules/grpc-reflection-js/build/src/client.d.ts b/node_modules/grpc-reflection-js/build/src/client.d.ts
+index e8acad8..9919874 100644
+--- a/node_modules/grpc-reflection-js/build/src/client.d.ts
++++ b/node_modules/grpc-reflection-js/build/src/client.d.ts
+@@ -3,7 +3,7 @@ import * as services from './reflection_grpc_pb';
+ import { Root } from 'protobufjs';
+ export declare class Client {
+     grpcClient: services.IServerReflectionClient;
+-    constructor(url: string, credentials: ChannelCredentials, options?: object);
++    constructor(url: string, credentials: ChannelCredentials, options?: object, descriptorExtensionProto?: string[]);
+     listServices(): Promise<string[] | void[]>;
+     fileContainingSymbol(symbol: string): Promise<Root>;
+     fileByFilename(filename: string): Promise<Root>;
+diff --git a/node_modules/grpc-reflection-js/build/src/client.js b/node_modules/grpc-reflection-js/build/src/client.js
+index d21ff4d..0f10f0b 100644
+--- a/node_modules/grpc-reflection-js/build/src/client.js
++++ b/node_modules/grpc-reflection-js/build/src/client.js
+@@ -26,11 +26,17 @@ exports.Client = void 0;
+ const descriptor_1 = require("./descriptor");
+ const services = __importStar(require("./reflection_grpc_pb"));
+ const reflection_pb_1 = require("./reflection_pb");
+-const descriptor_2 = require("protobufjs/ext/descriptor");
++const pb = require("protobufjs");
+ const lodash_set_1 = __importDefault(require("lodash.set"));
+ class Client {
+-    constructor(url, credentials, options) {
++    constructor(url, credentials, options, descriptorExtensionProto) {
+         this.grpcClient = new services.ServerReflectionClient(url, credentials, options);
++
++        const descriptorRoot = pb.Root.fromJSON(require("protobufjs/google/protobuf/descriptor.json"));
++        if (descriptorExtensionProto) {
++            descriptorExtensionProto.forEach((proto) => descriptorRoot.loadSync(proto));
++        }
++        this.descriptor = descriptorRoot.lookup(".google.protobuf");
+     }
+     listServices() {
+         return new Promise((resolve, reject) => {
+@@ -74,15 +80,15 @@ class Client {
+         });
+     }
+     async resolveFileDescriptorSet(fileDescriptorProtoBytes) {
+-        const fileDescriptorSet = descriptor_2.FileDescriptorSet.create();
++        const fileDescriptorSet = this.descriptor.FileDescriptorSet.create();
+         const fileDescriptorProtos = await this.resolveDescriptorRecursive(fileDescriptorProtoBytes);
+         lodash_set_1.default(fileDescriptorSet, 'file', Array.from(fileDescriptorProtos.values()));
+-        return descriptor_1.getDescriptorRootFromDescriptorSet(fileDescriptorSet);
++        return descriptor_1.getDescriptorRootFromDescriptorSet(fileDescriptorSet, this.descriptor);
+     }
+     async resolveDescriptorRecursive(fileDescriptorProtoBytes) {
+         let fileDescriptorProtos = new Map();
+         for (const descriptorByte of fileDescriptorProtoBytes) {
+-            const fileDescriptorProto = descriptor_2.FileDescriptorProto.decode(descriptorByte);
++            const fileDescriptorProto = this.descriptor.FileDescriptorProto.decode(descriptorByte);
+             if (fileDescriptorProto.dependency) {
+                 const dependencies = fileDescriptorProto.dependency;
+                 for (const dep of dependencies) {
+diff --git a/node_modules/grpc-reflection-js/build/src/descriptor.js b/node_modules/grpc-reflection-js/build/src/descriptor.js
+index a00a919..c680d3b 100644
+--- a/node_modules/grpc-reflection-js/build/src/descriptor.js
++++ b/node_modules/grpc-reflection-js/build/src/descriptor.js
+@@ -2,7 +2,7 @@
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.getDescriptorRootFromDescriptorSet = exports.getDescriptorRoot = void 0;
+ const protobuf = require('protobufjs');
+-const Descriptor = require('protobufjs/ext/descriptor');
++const Descriptor_1 = require('protobufjs/ext/descriptor');
+ const set = require('lodash.set');
+ /**
+  * @typedef {import('protobufjs').Root} Root
+@@ -15,7 +15,7 @@ const set = require('lodash.set');
+  * @return {Root} Protobuf.js Root object
+  */
+ // eslint-disable-next-line node/no-unsupported-features/es-syntax
+-function getDescriptorRoot(file_descriptor_protos) {
++function getDescriptorRoot(file_descriptor_protos, Descriptor = Descriptor_1) {
+     const descriptorSet = Descriptor.FileDescriptorSet.create();
+     file_descriptor_protos.forEach((descriptorByte, i) => {
+         const descriptor = Descriptor.FileDescriptorProto.decode(descriptorByte);
+@@ -30,7 +30,7 @@ exports.getDescriptorRoot = getDescriptorRoot;
+  * @return {Root} Protobuf.js Root object
+  */
+ // eslint-disable-next-line node/no-unsupported-features/es-syntax
+-function getDescriptorRootFromDescriptorSet(file_descriptor_set) {
++function getDescriptorRootFromDescriptorSet(file_descriptor_set, Descriptor = Descriptor_1) {
+     return protobuf.Root.fromDescriptor(file_descriptor_set);
+ }
+ exports.getDescriptorRootFromDescriptorSet = getDescriptorRootFromDescriptorSet;

package/patches/protobufjs+6.11.4.patch

@@ -0,0 +1,121 @@
+diff --git a/node_modules/protobufjs/ext/descriptor/index.js b/node_modules/protobufjs/ext/descriptor/index.js
+index 6aafd2a..b8e9f58 100644
+--- a/node_modules/protobufjs/ext/descriptor/index.js
++++ b/node_modules/protobufjs/ext/descriptor/index.js
+@@ -204,6 +204,8 @@ Type.fromDescriptor = function fromDescriptor(descriptor, syntax) {
+     if (typeof descriptor.length === "number")
+         descriptor = exports.DescriptorProto.decode(descriptor);
+ 
++    // record mapTypes for map fields
++    var mapTypes = {};
+     // Create the message type
+     var type = new Type(descriptor.name.length ? descriptor.name : "Type" + unnamedMessageIndex++, fromDescriptorOptions(descriptor.options, exports.MessageOptions)),
+         i;
+@@ -211,9 +213,34 @@ Type.fromDescriptor = function fromDescriptor(descriptor, syntax) {
+     /* Oneofs */ if (descriptor.oneofDecl)
+         for (i = 0; i < descriptor.oneofDecl.length; ++i)
+             type.add(OneOf.fromDescriptor(descriptor.oneofDecl[i]));
++    /* Nested types */ if (descriptor.nestedType)
++        for (i = 0; i < descriptor.nestedType.length; ++i) {
++            if (descriptor.nestedType[i].options && descriptor.nestedType[i].options.mapEntry && descriptor.nestedType[i].field.length === 2){
++                mapTypes[descriptor.nestedType[i].name] = [fromDescriptorType(descriptor.nestedType[i].field[0].type), descriptor.nestedType[i].field[1].typeName ? descriptor.nestedType[i].field[1].typeName : fromDescriptorType(descriptor.nestedType[i].field[1].type)];
++            }else{
++                type.add(Type.fromDescriptor(descriptor.nestedType[i], syntax));
++            }
++        }
+     /* Fields */ if (descriptor.field)
+         for (i = 0; i < descriptor.field.length; ++i) {
+-            var field = Field.fromDescriptor(descriptor.field[i], syntax);
++            var field = null;
++            while(!field) {
++                if(descriptor.field[i].typeName) {
++                    // after reflection in typeName maybe just short type name
++                    var foundedKvType = mapTypes[descriptor.field[i].typeName];
++                    if (!foundedKvType) {
++                        var nameParts = descriptor.field[i].typeName.split("."+type.name+".");
++                        if (nameParts.length===2) {
++                            foundedKvType = mapTypes[nameParts[1]];
++                        }
++                    }
++                    if(foundedKvType) {
++                        field = Field.fromDescriptor(descriptor.field[i], syntax, foundedKvType);
++                        break;
++                    }
++                }
++                field = Field.fromDescriptor(descriptor.field[i], syntax);
++            }
+             type.add(field);
+             if (descriptor.field[i].hasOwnProperty("oneofIndex")) // eslint-disable-line no-prototype-builtins
+                 type.oneofsArray[descriptor.field[i].oneofIndex].add(field);
+@@ -221,12 +248,6 @@ Type.fromDescriptor = function fromDescriptor(descriptor, syntax) {
+     /* Extension fields */ if (descriptor.extension)
+         for (i = 0; i < descriptor.extension.length; ++i)
+             type.add(Field.fromDescriptor(descriptor.extension[i], syntax));
+-    /* Nested types */ if (descriptor.nestedType)
+-        for (i = 0; i < descriptor.nestedType.length; ++i) {
+-            type.add(Type.fromDescriptor(descriptor.nestedType[i], syntax));
+-            if (descriptor.nestedType[i].options && descriptor.nestedType[i].options.mapEntry)
+-                type.setOption("map_entry", true);
+-        }
+     /* Nested enums */ if (descriptor.enumType)
+         for (i = 0; i < descriptor.enumType.length; ++i)
+             type.add(Enum.fromDescriptor(descriptor.enumType[i]));
+@@ -375,9 +396,10 @@ var numberRe = /^(?![eE])[0-9]*(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?$/;
+  * Creates a field from a descriptor.
+  * @param {IFieldDescriptorProto|Reader|Uint8Array} descriptor Descriptor
+  * @param {string} [syntax="proto2"] Syntax
+- * @returns {Field} Field instance
++ * @param {string[]} mapKv Key & value types for map field
++ * @returns {Field|MapField} Field instance
+  */
+-Field.fromDescriptor = function fromDescriptor(descriptor, syntax) {
++Field.fromDescriptor = function fromDescriptor(descriptor, syntax, mapKv) {
+ 
+     // Decode the descriptor message if specified as a buffer:
+     if (typeof descriptor.length === "number")
+@@ -407,8 +429,16 @@ Field.fromDescriptor = function fromDescriptor(descriptor, syntax) {
+ 	if (descriptor.extendee !== undefined) {
+ 		extendee = extendee.length ? extendee : undefined;
+ 	}
+-    var field = new Field(
+-        descriptor.name.length ? descriptor.name : "field" + descriptor.number,
++
++    var rawFieldName = descriptor.name.length ? descriptor.name : "field" + descriptor.number;
++    var fieldName = $protobuf.util.camelCase(rawFieldName);
++    var field = mapKv ? new MapField(
++        fieldName,
++        descriptor.number,
++        mapKv[0],
++        mapKv[1]
++    ) : new Field(
++        fieldName,
+         descriptor.number,
+         fieldType,
+         fieldRule,
+@@ -816,6 +846,12 @@ function fromDescriptorOptions(options, type) {
+                     val = field.resolvedType.valuesById[val];
+                 out.push(underScore(key), val);
+             }
++
++    for (var option in options) {
++        if (!type._fieldsArray.find(({name}) => name === option) && options.hasOwnProperty(option)) {
++            out.push(underScore(option), options[option]);
++        }
++    }
+     return out.length ? $protobuf.util.toObject(out) : undefined;
+ }
+ 
+diff --git a/node_modules/protobufjs/src/root.js b/node_modules/protobufjs/src/root.js
+index df6f11f..98303aa 100644
+--- a/node_modules/protobufjs/src/root.js
++++ b/node_modules/protobufjs/src/root.js
+@@ -273,6 +273,9 @@ function tryHandleExtension(root, field) {
+     var extendedType = field.parent.lookup(field.extend);
+     if (extendedType) {
+         var sisterField = new Field(field.fullName, field.id, field.type, field.rule, undefined, field.options);
++        if (extendedType.get(sisterField.name)) {
++            return true;
++        }
+         sisterField.declaringField = field;
+         field.extensionField = sisterField;
+         extendedType.add(sisterField);

package/proto/google/api/annotations.proto

@@ -0,0 +1,31 @@
+// Copyright (c) 2015, Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package google.api;
+
+import "google/api/http.proto";
+import "google/protobuf/descriptor.proto";
+
+option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations";
+option java_multiple_files = true;
+option java_outer_classname = "AnnotationsProto";
+option java_package = "com.google.api";
+option objc_class_prefix = "GAPI";
+
+extend google.protobuf.MethodOptions {
+  // See `HttpRule`.
+  HttpRule http = 72295728;
+}