From bcb9c03ffa133b7321a077c4395ea4ad952950ab Mon Sep 17 00:00:00 2001 From: Alexander Konotop Date: Mon, 18 Dec 2023 13:16:01 +0200 Subject: [PATCH 1/4] Fix generating wrong web-rpc implementation for wrapper-type method arguments --- src/generate-grpc-web.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/generate-grpc-web.ts b/src/generate-grpc-web.ts index 6bbe4f09b..7328b8025 100644 --- a/src/generate-grpc-web.ts +++ b/src/generate-grpc-web.ts @@ -50,7 +50,7 @@ function generateRpcMethod(ctx: Context, serviceDesc: ServiceDescriptorProto, me assertInstanceOf(methodDesc, FormattedMethodDescriptor); const { options } = ctx; const { useAbortSignal } = options; - const requestMessage = rawRequestType(ctx, methodDesc); + const requestMessage = requestType(ctx, methodDesc, false); const inputType = requestType(ctx, methodDesc, true); const returns = responsePromiseOrObservable(ctx, methodDesc); From a6f92744790ee79236363adc1806f985ff4c93d2 Mon Sep 17 00:00:00 2001 From: Alexander Konotop Date: Tue, 19 Dec 2023 15:55:40 +0200 Subject: [PATCH 2/4] Improve grpc-web tests to cover wrapper-containing rpc definitions --- integration/grpc-web/example.bin | Bin 3278 -> 8012 bytes integration/grpc-web/example.proto | 3 ++- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/integration/grpc-web/example.bin b/integration/grpc-web/example.bin index 72f331cf3e1bc492cb01c75424a58d5c31f7426c..a026de18a6110c1bab9b390e838a2fc786a93ca3 100644 GIT binary patch literal 8012 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 UpdU|LTAr4<=#;JOLfl~eKaghS6951J delta 866 zcmX|=%}&BV6oscVQ)~y&GV-f2CN2#W3}E zGFA&Qi%ej=oK-^D?Rn)-d6%2g>2G3;)Y9s@xbloKN=whGdJvhc(OODjRYTTH&iEvJ zQbDRP*a(ZMQc#sDW3XabX3GN>JIo_5ETmonE-sdslU6n5F?$kR({Yrm86Kt{ux7zB z2GNocTMAgqVG39)%%&bq9v-2n)XM6%xK8%1X{;Tb?e-~Z-Qm^{*w^8GP#ElRYbfmN zaBD>gyWAQASl40Hy34KM0qdePVkBBy-4i$a7#d?ej-e?=pZ7svU!V6uVX)8pps=sc zN8G)@0jGxmHgFil7;t)cz>)#S$NRNv=pIMMA3Bbz4c+4;xS@L-#E6ftB^`g{FuLl9 zj}MO~`S`xoV{wPl2|hU=V`FaZQ|k%GfWW>9?}NhNgkwNq--KiMlyJ&1Ab?FBMy;nD f10Jv`VubhxGPbH_BHDfU8BEQB{9|VKBenklRGvGb diff --git a/integration/grpc-web/example.proto b/integration/grpc-web/example.proto index f5ffd02b2..65909524c 100644 --- a/integration/grpc-web/example.proto +++ b/integration/grpc-web/example.proto @@ -1,5 +1,5 @@ syntax = "proto3"; - +import "google/protobuf/wrappers.proto"; package rpx; service DashState { @@ -40,6 +40,7 @@ service DashAPICreds { rpc Create(DashAPICredsCreateReq) returns (DashCred); rpc Update(DashAPICredsUpdateReq) returns (DashCred); rpc Delete(DashAPICredsDeleteReq) returns (DashCred); + rpc Uppercasse(google.protobuf.StringValue) returns (google.protobuf.StringValue); } message DashCred { From ca9afcbb533aec8b61dc651c2e9a285edf97f238 Mon Sep 17 00:00:00 2001 From: Alexander Konotop Date: Tue, 19 Dec 2023 15:59:47 +0200 Subject: [PATCH 3/4] Fix proto/rpc method naming misprint --- integration/grpc-web/example.bin | Bin 8012 -> 8011 bytes integration/grpc-web/example.proto | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/integration/grpc-web/example.bin b/integration/grpc-web/example.bin index a026de18a6110c1bab9b390e838a2fc786a93ca3..5de3fbf9b8a5c28e33668e0b5fba21b19a3c9788 100644 GIT binary patch delta 85 zcmX?OciL{l8$rgqo8JmbvM_#|%r3T`%bklew4flhC^>QSK`~!e?O-k*E><>1CT2z< aW-T^;7>^0a6VQh7n1MXAz|EF2!pr~&P7#~{ delta 86 zcmX?YcgAkR8$rf Date: Wed, 20 Dec 2023 09:24:52 -0600 Subject: [PATCH 4/4] Add changed example.ts. --- integration/grpc-web/example.ts | 30 + .../grpc-web/google/protobuf/wrappers.ts | 661 ++++++++++++++++++ 2 files changed, 691 insertions(+) create mode 100644 integration/grpc-web/google/protobuf/wrappers.ts diff --git a/integration/grpc-web/example.ts b/integration/grpc-web/example.ts index 1df53b05e..1ddc09bb7 100644 --- a/integration/grpc-web/example.ts +++ b/integration/grpc-web/example.ts @@ -4,6 +4,7 @@ import { BrowserHeaders } from "browser-headers"; import * as _m0 from "protobufjs/minimal"; import { Observable } from "rxjs"; import { share } from "rxjs/operators"; +import { StringValue } from "./google/protobuf/wrappers"; export const protobufPackage = "rpx"; @@ -826,6 +827,7 @@ export interface DashAPICreds { Create(request: DeepPartial, metadata?: grpc.Metadata): Promise; Update(request: DeepPartial, metadata?: grpc.Metadata): Promise; Delete(request: DeepPartial, metadata?: grpc.Metadata): Promise; + Uppercase(request: DeepPartial, metadata?: grpc.Metadata): Promise; } export class DashAPICredsClientImpl implements DashAPICreds { @@ -836,6 +838,7 @@ export class DashAPICredsClientImpl implements DashAPICreds { this.Create = this.Create.bind(this); this.Update = this.Update.bind(this); this.Delete = this.Delete.bind(this); + this.Uppercase = this.Uppercase.bind(this); } Create(request: DeepPartial, metadata?: grpc.Metadata): Promise { @@ -849,6 +852,10 @@ export class DashAPICredsClientImpl implements DashAPICreds { Delete(request: DeepPartial, metadata?: grpc.Metadata): Promise { return this.rpc.unary(DashAPICredsDeleteDesc, DashAPICredsDeleteReq.fromPartial(request), metadata); } + + Uppercase(request: DeepPartial, metadata?: grpc.Metadata): Promise { + return this.rpc.unary(DashAPICredsUppercaseDesc, StringValue.fromPartial(request), metadata); + } } export const DashAPICredsDesc = { serviceName: "rpx.DashAPICreds" }; @@ -922,6 +929,29 @@ export const DashAPICredsDeleteDesc: UnaryMethodDefinitionish = { } as any, }; +export const DashAPICredsUppercaseDesc: UnaryMethodDefinitionish = { + methodName: "Uppercase", + service: DashAPICredsDesc, + requestStream: false, + responseStream: false, + requestType: { + serializeBinary() { + return StringValue.encode(this).finish(); + }, + } as any, + responseType: { + deserializeBinary(data: Uint8Array) { + const value = StringValue.decode(data); + return { + ...value, + toObject() { + return value; + }, + }; + }, + } as any, +}; + interface UnaryMethodDefinitionishR extends grpc.UnaryMethodDefinition { requestStream: any; responseStream: any; diff --git a/integration/grpc-web/google/protobuf/wrappers.ts b/integration/grpc-web/google/protobuf/wrappers.ts new file mode 100644 index 000000000..6aa1a51cc --- /dev/null +++ b/integration/grpc-web/google/protobuf/wrappers.ts @@ -0,0 +1,661 @@ +/* eslint-disable */ +import * as _m0 from "protobufjs/minimal"; +import Long = require("long"); + +export const protobufPackage = "google.protobuf"; + +/** + * Wrapper message for `double`. + * + * The JSON representation for `DoubleValue` is JSON number. + */ +export interface DoubleValue { + /** The double value. */ + value: number; +} + +/** + * Wrapper message for `float`. + * + * The JSON representation for `FloatValue` is JSON number. + */ +export interface FloatValue { + /** The float value. */ + value: number; +} + +/** + * Wrapper message for `int64`. + * + * The JSON representation for `Int64Value` is JSON string. + */ +export interface Int64Value { + /** The int64 value. */ + value: number; +} + +/** + * Wrapper message for `uint64`. + * + * The JSON representation for `UInt64Value` is JSON string. + */ +export interface UInt64Value { + /** The uint64 value. */ + value: number; +} + +/** + * Wrapper message for `int32`. + * + * The JSON representation for `Int32Value` is JSON number. + */ +export interface Int32Value { + /** The int32 value. */ + value: number; +} + +/** + * Wrapper message for `uint32`. + * + * The JSON representation for `UInt32Value` is JSON number. + */ +export interface UInt32Value { + /** The uint32 value. */ + value: number; +} + +/** + * Wrapper message for `bool`. + * + * The JSON representation for `BoolValue` is JSON `true` and `false`. + */ +export interface BoolValue { + /** The bool value. */ + value: boolean; +} + +/** + * Wrapper message for `string`. + * + * The JSON representation for `StringValue` is JSON string. + */ +export interface StringValue { + /** The string value. */ + value: string; +} + +/** + * Wrapper message for `bytes`. + * + * The JSON representation for `BytesValue` is JSON string. + */ +export interface BytesValue { + /** The bytes value. */ + value: Uint8Array; +} + +function createBaseDoubleValue(): DoubleValue { + return { value: 0 }; +} + +export const DoubleValue = { + encode(message: DoubleValue, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.value !== 0) { + writer.uint32(9).double(message.value); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): DoubleValue { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDoubleValue(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 9) { + break; + } + + message.value = reader.double(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): DoubleValue { + return { value: isSet(object.value) ? globalThis.Number(object.value) : 0 }; + }, + + toJSON(message: DoubleValue): unknown { + const obj: any = {}; + if (message.value !== 0) { + obj.value = message.value; + } + return obj; + }, + + create, I>>(base?: I): DoubleValue { + return DoubleValue.fromPartial(base ?? ({} as any)); + }, + fromPartial, I>>(object: I): DoubleValue { + const message = createBaseDoubleValue(); + message.value = object.value ?? 0; + return message; + }, +}; + +function createBaseFloatValue(): FloatValue { + return { value: 0 }; +} + +export const FloatValue = { + encode(message: FloatValue, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.value !== 0) { + writer.uint32(13).float(message.value); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): FloatValue { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFloatValue(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 13) { + break; + } + + message.value = reader.float(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): FloatValue { + return { value: isSet(object.value) ? globalThis.Number(object.value) : 0 }; + }, + + toJSON(message: FloatValue): unknown { + const obj: any = {}; + if (message.value !== 0) { + obj.value = message.value; + } + return obj; + }, + + create, I>>(base?: I): FloatValue { + return FloatValue.fromPartial(base ?? ({} as any)); + }, + fromPartial, I>>(object: I): FloatValue { + const message = createBaseFloatValue(); + message.value = object.value ?? 0; + return message; + }, +}; + +function createBaseInt64Value(): Int64Value { + return { value: 0 }; +} + +export const Int64Value = { + encode(message: Int64Value, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.value !== 0) { + writer.uint32(8).int64(message.value); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Int64Value { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseInt64Value(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.value = longToNumber(reader.int64() as Long); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): Int64Value { + return { value: isSet(object.value) ? globalThis.Number(object.value) : 0 }; + }, + + toJSON(message: Int64Value): unknown { + const obj: any = {}; + if (message.value !== 0) { + obj.value = Math.round(message.value); + } + return obj; + }, + + create, I>>(base?: I): Int64Value { + return Int64Value.fromPartial(base ?? ({} as any)); + }, + fromPartial, I>>(object: I): Int64Value { + const message = createBaseInt64Value(); + message.value = object.value ?? 0; + return message; + }, +}; + +function createBaseUInt64Value(): UInt64Value { + return { value: 0 }; +} + +export const UInt64Value = { + encode(message: UInt64Value, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.value !== 0) { + writer.uint32(8).uint64(message.value); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): UInt64Value { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUInt64Value(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.value = longToNumber(reader.uint64() as Long); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): UInt64Value { + return { value: isSet(object.value) ? globalThis.Number(object.value) : 0 }; + }, + + toJSON(message: UInt64Value): unknown { + const obj: any = {}; + if (message.value !== 0) { + obj.value = Math.round(message.value); + } + return obj; + }, + + create, I>>(base?: I): UInt64Value { + return UInt64Value.fromPartial(base ?? ({} as any)); + }, + fromPartial, I>>(object: I): UInt64Value { + const message = createBaseUInt64Value(); + message.value = object.value ?? 0; + return message; + }, +}; + +function createBaseInt32Value(): Int32Value { + return { value: 0 }; +} + +export const Int32Value = { + encode(message: Int32Value, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.value !== 0) { + writer.uint32(8).int32(message.value); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Int32Value { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseInt32Value(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.value = reader.int32(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): Int32Value { + return { value: isSet(object.value) ? globalThis.Number(object.value) : 0 }; + }, + + toJSON(message: Int32Value): unknown { + const obj: any = {}; + if (message.value !== 0) { + obj.value = Math.round(message.value); + } + return obj; + }, + + create, I>>(base?: I): Int32Value { + return Int32Value.fromPartial(base ?? ({} as any)); + }, + fromPartial, I>>(object: I): Int32Value { + const message = createBaseInt32Value(); + message.value = object.value ?? 0; + return message; + }, +}; + +function createBaseUInt32Value(): UInt32Value { + return { value: 0 }; +} + +export const UInt32Value = { + encode(message: UInt32Value, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.value !== 0) { + writer.uint32(8).uint32(message.value); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): UInt32Value { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUInt32Value(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.value = reader.uint32(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): UInt32Value { + return { value: isSet(object.value) ? globalThis.Number(object.value) : 0 }; + }, + + toJSON(message: UInt32Value): unknown { + const obj: any = {}; + if (message.value !== 0) { + obj.value = Math.round(message.value); + } + return obj; + }, + + create, I>>(base?: I): UInt32Value { + return UInt32Value.fromPartial(base ?? ({} as any)); + }, + fromPartial, I>>(object: I): UInt32Value { + const message = createBaseUInt32Value(); + message.value = object.value ?? 0; + return message; + }, +}; + +function createBaseBoolValue(): BoolValue { + return { value: false }; +} + +export const BoolValue = { + encode(message: BoolValue, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.value === true) { + writer.uint32(8).bool(message.value); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): BoolValue { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseBoolValue(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 8) { + break; + } + + message.value = reader.bool(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): BoolValue { + return { value: isSet(object.value) ? globalThis.Boolean(object.value) : false }; + }, + + toJSON(message: BoolValue): unknown { + const obj: any = {}; + if (message.value === true) { + obj.value = message.value; + } + return obj; + }, + + create, I>>(base?: I): BoolValue { + return BoolValue.fromPartial(base ?? ({} as any)); + }, + fromPartial, I>>(object: I): BoolValue { + const message = createBaseBoolValue(); + message.value = object.value ?? false; + return message; + }, +}; + +function createBaseStringValue(): StringValue { + return { value: "" }; +} + +export const StringValue = { + encode(message: StringValue, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.value !== "") { + writer.uint32(10).string(message.value); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): StringValue { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseStringValue(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.value = reader.string(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): StringValue { + return { value: isSet(object.value) ? globalThis.String(object.value) : "" }; + }, + + toJSON(message: StringValue): unknown { + const obj: any = {}; + if (message.value !== "") { + obj.value = message.value; + } + return obj; + }, + + create, I>>(base?: I): StringValue { + return StringValue.fromPartial(base ?? ({} as any)); + }, + fromPartial, I>>(object: I): StringValue { + const message = createBaseStringValue(); + message.value = object.value ?? ""; + return message; + }, +}; + +function createBaseBytesValue(): BytesValue { + return { value: new Uint8Array(0) }; +} + +export const BytesValue = { + encode(message: BytesValue, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.value.length !== 0) { + writer.uint32(10).bytes(message.value); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): BytesValue { + const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseBytesValue(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (tag !== 10) { + break; + } + + message.value = reader.bytes(); + continue; + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skipType(tag & 7); + } + return message; + }, + + fromJSON(object: any): BytesValue { + return { value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(0) }; + }, + + toJSON(message: BytesValue): unknown { + const obj: any = {}; + if (message.value.length !== 0) { + obj.value = base64FromBytes(message.value); + } + return obj; + }, + + create, I>>(base?: I): BytesValue { + return BytesValue.fromPartial(base ?? ({} as any)); + }, + fromPartial, I>>(object: I): BytesValue { + const message = createBaseBytesValue(); + message.value = object.value ?? new Uint8Array(0); + return message; + }, +}; + +function bytesFromBase64(b64: string): Uint8Array { + if (globalThis.Buffer) { + return Uint8Array.from(globalThis.Buffer.from(b64, "base64")); + } else { + const bin = globalThis.atob(b64); + const arr = new Uint8Array(bin.length); + for (let i = 0; i < bin.length; ++i) { + arr[i] = bin.charCodeAt(i); + } + return arr; + } +} + +function base64FromBytes(arr: Uint8Array): string { + if (globalThis.Buffer) { + return globalThis.Buffer.from(arr).toString("base64"); + } else { + const bin: string[] = []; + arr.forEach((byte) => { + bin.push(globalThis.String.fromCharCode(byte)); + }); + return globalThis.btoa(bin.join("")); + } +} + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin ? T + : T extends globalThis.Array ? globalThis.Array> + : T extends ReadonlyArray ? ReadonlyArray> + : T extends {} ? { [K in keyof T]?: DeepPartial } + : Partial; + +type KeysOfUnion = T extends T ? keyof T : never; +export type Exact = P extends Builtin ? P + : P & { [K in keyof P]: Exact } & { [K in Exclude>]: never }; + +function longToNumber(long: Long): number { + if (long.gt(globalThis.Number.MAX_SAFE_INTEGER)) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + return long.toNumber(); +} + +if (_m0.util.Long !== Long) { + _m0.util.Long = Long as any; + _m0.configure(); +} + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +}