$3

About the code changes, please read the doc at Changes part. Also, please read this doc for more information: @grpc/grpc-js server implementation signature issue.

$3

$3

$3

TSLint has been disabled in generated files. Please see the conversation: #13.

How to use

generate js codes via grpc-tools

generate d.ts codes

Example

Dirs:

* proto: sample proto definition
* bash: useful commands
build.sh: build js & d.ts codes from proto file, and tsc to build/.js
* server.sh: start the server
* client.sh: start the client & send requests

$3

package com.book;

message Book {
int64 isbn = 1;
string title = 2;
string author = 3;
}

message GetBookRequest {
int64 isbn = 1;
}

message GetBookViaAuthor {
string author = 1;
}

service BookService {
rpc GetBook (GetBookRequest) returns (Book) {}
rpc GetBooksViaAuthor (GetBookViaAuthor) returns (stream Book) {}
rpc GetGreatestBook (stream GetBookRequest) returns (Book) {}
rpc GetBooks (stream GetBookRequest) returns (stream Book) {}
}

message BookStore {
string name = 1;
map books = 2;
}

enum EnumSample {
option allow_alias = true;
UNKNOWN = 0;
STARTED = 1;
RUNNING = 1;
caseTest = 2;
How_about_This = 3;
alllowercase = 4;
}

// Message with reserved keywords
// see: https://github.com/google/protobuf/blob/cc3fa2ec80d196e045ae05797799f079188106f3/js/compatibility_tests/v3.0.0/test.proto#L66-L72
message SpecialCases {
string normal = 1;
// Examples of Js reserved names that are converted to pb_.
string default = 2;
string function = 3;
string var = 4;
}

message OneOfSample {
oneof singleword {
bool a1 = 1;
bool b1 = 2;
}

oneof two_words {
bool a_2 = 3;
bool b_2 = 4;
}
}

message ExtMsgString {
string extension = 1;
}

message ExtMsgList {
repeated string extension = 1;
}

message ExtMsgByte {
bytes extension = 1;
}

message ExtMsgByteList {
repeated bytes extension = 1;
}

message ExtMsgMap {
map extension = 1;
}

message ExtMsgOneOf {
oneof ext {
string extension = 1;
}
}

/ tslint:disable /
/ eslint-disable /

import * as jspb from "google-protobuf";

export class Book extends jspb.Message {
getIsbn(): number;
setIsbn(value: number): Book;
getTitle(): string;
setTitle(value: string): Book;
getAuthor(): string;
setAuthor(value: string): Book;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Book.AsObject;
static toObject(includeInstance: boolean, msg: Book): Book.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: Book, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Book;
static deserializeBinaryFromReader(message: Book, reader: jspb.BinaryReader): Book;
}

export namespace Book {
export type AsObject = {
isbn: number,
title: string,
author: string,
}
}

export class GetBookRequest extends jspb.Message {
getIsbn(): number;
setIsbn(value: number): GetBookRequest;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetBookRequest.AsObject;
static toObject(includeInstance: boolean, msg: GetBookRequest): GetBookRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: GetBookRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetBookRequest;
static deserializeBinaryFromReader(message: GetBookRequest, reader: jspb.BinaryReader): GetBookRequest;
}

export namespace GetBookRequest {
export type AsObject = {
isbn: number,
}
}

export class GetBookViaAuthor extends jspb.Message {
getAuthor(): string;
setAuthor(value: string): GetBookViaAuthor;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetBookViaAuthor.AsObject;
static toObject(includeInstance: boolean, msg: GetBookViaAuthor): GetBookViaAuthor.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: GetBookViaAuthor, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetBookViaAuthor;
static deserializeBinaryFromReader(message: GetBookViaAuthor, reader: jspb.BinaryReader): GetBookViaAuthor;
}

export namespace GetBookViaAuthor {
export type AsObject = {
author: string,
}
}

export class BookStore extends jspb.Message {
getName(): string;
setName(value: string): BookStore;

getBooksMap(): jspb.Map;
clearBooksMap(): void;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): BookStore.AsObject;
static toObject(includeInstance: boolean, msg: BookStore): BookStore.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: BookStore, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): BookStore;
static deserializeBinaryFromReader(message: BookStore, reader: jspb.BinaryReader): BookStore;
}

export namespace BookStore {
export type AsObject = {
name: string,

booksMap: Array<[number, string]>,
}
}

export class SpecialCases extends jspb.Message {
getNormal(): string;
setNormal(value: string): SpecialCases;
getDefault(): string;
setDefault(value: string): SpecialCases;
getFunction(): string;
setFunction(value: string): SpecialCases;
getVar(): string;
setVar(value: string): SpecialCases;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): SpecialCases.AsObject;
static toObject(includeInstance: boolean, msg: SpecialCases): SpecialCases.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: SpecialCases, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): SpecialCases;
static deserializeBinaryFromReader(message: SpecialCases, reader: jspb.BinaryReader): SpecialCases;
}

export namespace SpecialCases {
export type AsObject = {
normal: string,
pb_default: string,
pb_function: string,
pb_var: string,
}
}

export class OneOfSample extends jspb.Message {

hasA1(): boolean;
clearA1(): void;
getA1(): boolean;
setA1(value: boolean): OneOfSample;

hasB1(): boolean;
clearB1(): void;
getB1(): boolean;
setB1(value: boolean): OneOfSample;

hasA2(): boolean;
clearA2(): void;
getA2(): boolean;
setA2(value: boolean): OneOfSample;

hasB2(): boolean;
clearB2(): void;
getB2(): boolean;
setB2(value: boolean): OneOfSample;

getSinglewordCase(): OneOfSample.SinglewordCase;
getTwoWordsCase(): OneOfSample.TwoWordsCase;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): OneOfSample.AsObject;
static toObject(includeInstance: boolean, msg: OneOfSample): OneOfSample.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: OneOfSample, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): OneOfSample;
static deserializeBinaryFromReader(message: OneOfSample, reader: jspb.BinaryReader): OneOfSample;
}

export namespace OneOfSample {
export type AsObject = {
a1: boolean,
b1: boolean,
a2: boolean,
b2: boolean,
}

export enum SinglewordCase {
SINGLEWORD_NOT_SET = 0,
A1 = 1,
B1 = 2,
}

export enum TwoWordsCase {
TWO_WORDS_NOT_SET = 0,
A_2 = 3,
B_2 = 4,
}

}

export class ExtMsgString extends jspb.Message {
getExtension$(): string;
setExtension$(value: string): ExtMsgString;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ExtMsgString.AsObject;
static toObject(includeInstance: boolean, msg: ExtMsgString): ExtMsgString.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: ExtMsgString, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ExtMsgString;
static deserializeBinaryFromReader(message: ExtMsgString, reader: jspb.BinaryReader): ExtMsgString;
}

export namespace ExtMsgString {
export type AsObject = {
extension: string,
}
}

export class ExtMsgList extends jspb.Message {
clearExtensionList(): void;
getExtensionList(): Array;
setExtensionList(value: Array): ExtMsgList;
addExtension$(value: string, index?: number): string;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ExtMsgList.AsObject;
static toObject(includeInstance: boolean, msg: ExtMsgList): ExtMsgList.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: ExtMsgList, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ExtMsgList;
static deserializeBinaryFromReader(message: ExtMsgList, reader: jspb.BinaryReader): ExtMsgList;
}

export namespace ExtMsgList {
export type AsObject = {
extensionList: Array,
}
}

export class ExtMsgByte extends jspb.Message {
getExtension$(): Uint8Array | string;
getExtension_asU8(): Uint8Array;
getExtension_asB64(): string;
setExtension$(value: Uint8Array | string): ExtMsgByte;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ExtMsgByte.AsObject;
static toObject(includeInstance: boolean, msg: ExtMsgByte): ExtMsgByte.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: ExtMsgByte, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ExtMsgByte;
static deserializeBinaryFromReader(message: ExtMsgByte, reader: jspb.BinaryReader): ExtMsgByte;
}

export namespace ExtMsgByte {
export type AsObject = {
extension: Uint8Array | string,
}
}

export class ExtMsgByteList extends jspb.Message {
clearExtensionList(): void;
getExtensionList(): Array;
getExtensionList_asU8(): Array;
getExtensionList_asB64(): Array;
setExtensionList(value: Array): ExtMsgByteList;
addExtension$(value: Uint8Array | string, index?: number): Uint8Array | string;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ExtMsgByteList.AsObject;
static toObject(includeInstance: boolean, msg: ExtMsgByteList): ExtMsgByteList.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: ExtMsgByteList, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ExtMsgByteList;
static deserializeBinaryFromReader(message: ExtMsgByteList, reader: jspb.BinaryReader): ExtMsgByteList;
}

export namespace ExtMsgByteList {
export type AsObject = {
extensionList: Array,
}
}

export class ExtMsgMap extends jspb.Message {

getExtensionMap(): jspb.Map;
clearExtensionMap(): void;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ExtMsgMap.AsObject;
static toObject(includeInstance: boolean, msg: ExtMsgMap): ExtMsgMap.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: ExtMsgMap, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ExtMsgMap;
static deserializeBinaryFromReader(message: ExtMsgMap, reader: jspb.BinaryReader): ExtMsgMap;
}

export namespace ExtMsgMap {
export type AsObject = {

extensionMap: Array<[string, string]>,
}
}

export class ExtMsgOneOf extends jspb.Message {

hasExtension$(): boolean;
clearExtension$(): void;
getExtension$(): string;
setExtension$(value: string): ExtMsgOneOf;

getExtCase(): ExtMsgOneOf.ExtCase;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ExtMsgOneOf.AsObject;
static toObject(includeInstance: boolean, msg: ExtMsgOneOf): ExtMsgOneOf.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: ExtMsgOneOf, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ExtMsgOneOf;
static deserializeBinaryFromReader(message: ExtMsgOneOf, reader: jspb.BinaryReader): ExtMsgOneOf;
}

export namespace ExtMsgOneOf {
export type AsObject = {
extension: string,
}

export enum ExtCase {
EXT_NOT_SET = 0,
EXTENSION = 1,
}

}

export class OptTest extends jspb.Message {

hasName(): boolean;
clearName(): void;
getName(): string | undefined;
setName(value: string): OptTest;

serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): OptTest.AsObject;
static toObject(includeInstance: boolean, msg: OptTest): OptTest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
static serializeBinaryToWriter(message: OptTest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): OptTest;
static deserializeBinaryFromReader(message: OptTest, reader: jspb.BinaryReader): OptTest;
}

export namespace OptTest {
export type AsObject = {
name?: string,
}
}

/ tslint:disable /
/ eslint-disable /

import * as grpc from "@grpc/grpc-js";
import * as book_pb from "./book_pb";

interface IBookServiceService extends grpc.ServiceDefinition {
getBook: IBookServiceService_IGetBook;
getBooksViaAuthor: IBookServiceService_IGetBooksViaAuthor;
getGreatestBook: IBookServiceService_IGetGreatestBook;
getBooks: IBookServiceService_IGetBooks;
}

interface IBookServiceService_IGetBook extends grpc.MethodDefinition {
path: "/com.book.BookService/GetBook";
requestStream: false;
responseStream: false;
requestSerialize: grpc.serialize;
requestDeserialize: grpc.deserialize;
responseSerialize: grpc.serialize;
responseDeserialize: grpc.deserialize;
}
interface IBookServiceService_IGetBooksViaAuthor extends grpc.MethodDefinition {
path: "/com.book.BookService/GetBooksViaAuthor";
requestStream: false;
responseStream: true;
requestSerialize: grpc.serialize;
requestDeserialize: grpc.deserialize;
responseSerialize: grpc.serialize;
responseDeserialize: grpc.deserialize;
}
interface IBookServiceService_IGetGreatestBook extends grpc.MethodDefinition {
path: "/com.book.BookService/GetGreatestBook";
requestStream: true;
responseStream: false;
requestSerialize: grpc.serialize;
requestDeserialize: grpc.deserialize;
responseSerialize: grpc.serialize;
responseDeserialize: grpc.deserialize;
}
interface IBookServiceService_IGetBooks extends grpc.MethodDefinition {
path: "/com.book.BookService/GetBooks";
requestStream: true;
responseStream: true;
requestSerialize: grpc.serialize;
requestDeserialize: grpc.deserialize;
responseSerialize: grpc.serialize;
responseDeserialize: grpc.deserialize;
}

export const BookServiceService: IBookServiceService;

export interface IBookServiceServer extends grpc.UntypedServiceImplementation {
getBook: grpc.handleUnaryCall;
getBooksViaAuthor: grpc.handleServerStreamingCall;
getGreatestBook: grpc.handleClientStreamingCall;
getBooks: grpc.handleBidiStreamingCall;
}

export interface IBookServiceClient {
getBook(request: book_pb.GetBookRequest, callback: (error: grpc.ServiceError | null, response: book_pb.Book) => void): grpc.ClientUnaryCall;
getBook(request: book_pb.GetBookRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: book_pb.Book) => void): grpc.ClientUnaryCall;
getBook(request: book_pb.GetBookRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: book_pb.Book) => void): grpc.ClientUnaryCall;
getBooksViaAuthor(request: book_pb.GetBookViaAuthor, options?: Partial): grpc.ClientReadableStream;
getBooksViaAuthor(request: book_pb.GetBookViaAuthor, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream;
getGreatestBook(callback: (error: grpc.ServiceError | null, response: book_pb.Book) => void): grpc.ClientWritableStream;
getGreatestBook(metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: book_pb.Book) => void): grpc.ClientWritableStream;
getGreatestBook(options: Partial, callback: (error: grpc.ServiceError | null, response: book_pb.Book) => void): grpc.ClientWritableStream;
getGreatestBook(metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: book_pb.Book) => void): grpc.ClientWritableStream;
getBooks(): grpc.ClientDuplexStream;
getBooks(options: Partial): grpc.ClientDuplexStream;
getBooks(metadata: grpc.Metadata, options?: Partial): grpc.ClientDuplexStream;
}

$3

$3

Updated doc could be found here: @grpc/grpc-js server implementation signature issue.

$3

$3

$3

Some info:

- google-protobuf changes: https://github.com/protocolbuffers/protobuf/blob/master/CHANGES.txt
- google-protobuf releases: https://github.com/protocolbuffers/protobuf/releases
- grpc-tools releases: https://github.com/grpc/grpc-node/releases

$3

$3

$3

$3

$3

Two points:

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

$3

About jstype options of protobuf

If you want your project to have no vulnerabilities detected, you could simply install this tool into global (out of your application project). And use it when you want to generate the typescript signature in development as usual.

About Docker

v10.15.2

6.14.4

libprotoc 3.11.1

libprotoc 3.11.4

grpc-tools@1.9.1

Version 3.7.3