[TS] GRPC Implementation (#6141)

* GRPC implementation for Typescript

* Fixes a couple of issues

* Finished implementing the typescript support for grpc

* Updated generated code

* Fixes CI

tests/FlatBuffers.GRPC.Swift/Sources/Model/greeter.grpc.swift

@@ -49,8 +49,10 @@ public protocol GreeterProvider: CallHandlerProvider {
 }
 
 public extension GreeterProvider {
-	var serviceName: String { return "Greeter" }
-	func handleMethod(_ methodName: String, callHandlerContext: CallHandlerContext) -> GRPCCallHandler? {
+
+	var serviceName: Substring { return "Greeter" }
+
+	func handleMethod(_ methodName: Substring, callHandlerContext: CallHandlerContext) -> GRPCCallHandler? {
 		switch methodName {
 		case "SayHello":
 		return CallHandlerFactory.makeUnary(callHandlerContext: callHandlerContext) { context in

tests/FlatBuffers.GRPC.Swift/Sources/client/main.swift

@@ -36,6 +36,7 @@ func greet(name: String, client greeter: GreeterServiceClient) {
     
     // Make the RPC call to the server.
     let sayHello = greeter.SayHello(Message<HelloRequest>(builder: &builder))
+
     // wait() on the response to stop the program from exiting before the response is received.
     do {
         let response = try sayHello.response.wait()
@@ -43,15 +44,15 @@ func greet(name: String, client greeter: GreeterServiceClient) {
     } catch {
         print("Greeter failed: \(error)")
     }
-    
+
     let surname = builder.create(string: "Name")
     let manyRoot = ManyHellosRequest.createManyHellosRequest(&builder, offsetOfName: surname, numGreetings: 2)
     builder.finish(offset: manyRoot)
-    
+
     let call = greeter.SayManyHellos(Message(builder: &builder)) { message in
         print(message.object.message)
     }
-    
+
     let status = try! call.status.recover { _ in .processingError }.wait()
     if status.code != .ok {
       print("RPC failed: \(status)")
@@ -83,10 +84,15 @@ func main(args: [String]) {
         // Configure the channel, we're not using TLS so the connection is `insecure`.
         let channel = ClientConnection.insecure(group: group)
           .connect(host: "localhost", port: port)
-        
+
+        // Close the connection when we're done with it.
+        defer {
+          try! channel.close().wait()
+        }
+
         // Provide the connection to the generated client.
         let greeter = GreeterServiceClient(channel: channel)
-        
+
         // Do the greeting.
         greet(name: name ?? "Hello FlatBuffers!", client: greeter)
     }

tests/FlatBuffers.GRPC.Swift/Sources/server/main.swift

@@ -40,7 +40,7 @@ class Greeter: GreeterProvider {
         context: StatusOnlyCallContext
     ) -> EventLoopFuture<Message<HelloReply>> {
         let recipient = request.object.name ?? "Stranger"
-        
+
         var builder = FlatBufferBuilder()
         let off = builder.create(string: recipient)
         let root = HelloReply.createHelloReply(&builder, offsetOfMessage: off)

tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test.grpc.swift

@@ -61,8 +61,10 @@ public protocol MyGame_Example_MonsterStorageProvider: CallHandlerProvider {
 }
 
 public extension MyGame_Example_MonsterStorageProvider {
-	var serviceName: String { return "MyGame.Example.MonsterStorage" }
-	func handleMethod(_ methodName: String, callHandlerContext: CallHandlerContext) -> GRPCCallHandler? {
+
+	var serviceName: Substring { return "MyGame.Example.MonsterStorage" }
+
+	func handleMethod(_ methodName: Substring, callHandlerContext: CallHandlerContext) -> GRPCCallHandler? {
 		switch methodName {
 		case "Store":
 		return CallHandlerFactory.makeUnary(callHandlerContext: callHandlerContext) { context in

tests/monster_test_generated.ts

@@ -210,6 +210,14 @@ static createInParentNamespace(builder:flatbuffers.Builder):flatbuffers.Offset {
   return InParentNamespace.endInParentNamespace(builder);
 }
 
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):InParentNamespace {
+  return InParentNamespace.getRootAsInParentNamespace(new flatbuffers.ByteBuffer(buffer))
+}
+
 /**
  * @returns InParentNamespaceT
  */
@@ -297,6 +305,14 @@ static createMonster(builder:flatbuffers.Builder):flatbuffers.Offset {
   return Monster.endMonster(builder);
 }
 
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):Monster {
+  return Monster.getRootAsMonster(new flatbuffers.ByteBuffer(buffer))
+}
+
 /**
  * @returns MonsterT
  */
@@ -531,6 +547,14 @@ static createTestSimpleTableWithEnum(builder:flatbuffers.Builder, color:MyGame.E
   return TestSimpleTableWithEnum.endTestSimpleTableWithEnum(builder);
 }
 
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):TestSimpleTableWithEnum {
+  return TestSimpleTableWithEnum.getRootAsTestSimpleTableWithEnum(new flatbuffers.ByteBuffer(buffer))
+}
+
 /**
  * @returns TestSimpleTableWithEnumT
  */
@@ -1031,6 +1055,14 @@ static createStat(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset, val:
   return Stat.endStat(builder);
 }
 
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):Stat {
+  return Stat.getRootAsStat(new flatbuffers.ByteBuffer(buffer))
+}
+
 /**
  * @returns StatT
  */
@@ -1171,6 +1203,14 @@ static createReferrable(builder:flatbuffers.Builder, id:flatbuffers.Long):flatbu
   return Referrable.endReferrable(builder);
 }
 
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):Referrable {
+  return Referrable.getRootAsReferrable(new flatbuffers.ByteBuffer(buffer))
+}
+
 /**
  * @returns ReferrableT
  */
@@ -2922,6 +2962,14 @@ static finishSizePrefixedMonsterBuffer(builder:flatbuffers.Builder, offset:flatb
 };
 
 
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):Monster {
+  return Monster.getRootAsMonster(new flatbuffers.ByteBuffer(buffer))
+}
+
 /**
  * @returns MonsterT
  */
@@ -3741,6 +3789,14 @@ static createTypeAliases(builder:flatbuffers.Builder, i8:number, u8:number, i16:
   return TypeAliases.endTypeAliases(builder);
 }
 
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):TypeAliases {
+  return TypeAliases.getRootAsTypeAliases(new flatbuffers.ByteBuffer(buffer))
+}
+
 /**
  * @returns TypeAliasesT
  */

tests/monster_test_grpc.d.ts

@@ -0,0 +1,92 @@
+// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***
+import { flatbuffers } from 'flatbuffers';
+import *  as MonsterStorage_fbs from './monster_test_generated';
+
+import * as grpc from 'grpc';
+
+interface IMonsterStorageService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  Store: IMonsterStorageService_IStore;
+  Retrieve: IMonsterStorageService_IRetrieve;
+  GetMaxHitPoint: IMonsterStorageService_IGetMaxHitPoint;
+  GetMinMaxHitPoints: IMonsterStorageService_IGetMinMaxHitPoints;
+}
+interface IMonsterStorageService_IStore extends grpc.MethodDefinition<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat> {
+  path: string; // /MyGame.Example.MonsterStorage/Store
+  requestStream: boolean; // false
+  responseStream: boolean; // false
+  requestSerialize: grpc.serialize<MonsterStorage_fbs.Monster>;
+  requestDeserialize: grpc.deserialize<MonsterStorage_fbs.Monster>;
+  responseSerialize: grpc.serialize<MonsterStorage_fbs.Stat>;
+  responseDeserialize: grpc.deserialize<MonsterStorage_fbs.Stat>;
+}
+
+interface IMonsterStorageService_IRetrieve extends grpc.MethodDefinition<MonsterStorage_fbs.Stat, MonsterStorage_fbs.Monster> {
+  path: string; // /MyGame.Example.MonsterStorage/Retrieve
+  requestStream: boolean; // false
+  responseStream: boolean; // true
+  requestSerialize: grpc.serialize<MonsterStorage_fbs.Stat>;
+  requestDeserialize: grpc.deserialize<MonsterStorage_fbs.Stat>;
+  responseSerialize: grpc.serialize<MonsterStorage_fbs.Monster>;
+  responseDeserialize: grpc.deserialize<MonsterStorage_fbs.Monster>;
+}
+
+interface IMonsterStorageService_IGetMaxHitPoint extends grpc.MethodDefinition<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat> {
+  path: string; // /MyGame.Example.MonsterStorage/GetMaxHitPoint
+  requestStream: boolean; // true
+  responseStream: boolean; // false
+  requestSerialize: grpc.serialize<MonsterStorage_fbs.Monster>;
+  requestDeserialize: grpc.deserialize<MonsterStorage_fbs.Monster>;
+  responseSerialize: grpc.serialize<MonsterStorage_fbs.Stat>;
+  responseDeserialize: grpc.deserialize<MonsterStorage_fbs.Stat>;
+}
+
+interface IMonsterStorageService_IGetMinMaxHitPoints extends grpc.MethodDefinition<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat> {
+  path: string; // /MyGame.Example.MonsterStorage/GetMinMaxHitPoints
+  requestStream: boolean; // true
+  responseStream: boolean; // true
+  requestSerialize: grpc.serialize<MonsterStorage_fbs.Monster>;
+  requestDeserialize: grpc.deserialize<MonsterStorage_fbs.Monster>;
+  responseSerialize: grpc.serialize<MonsterStorage_fbs.Stat>;
+  responseDeserialize: grpc.deserialize<MonsterStorage_fbs.Stat>;
+}
+
+
+export const MonsterStorageService: IMonsterStorageService;
+
+export interface IMonsterStorageServer {
+  Store: grpc.handleUnaryCall<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
+  Retrieve: grpc.handleServerStreamingCall<MonsterStorage_fbs.Stat, MonsterStorage_fbs.Monster>;
+  GetMaxHitPoint: grpc.handleClientStreamingCall<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
+  GetMinMaxHitPoints: grpc.handleBidiStreamingCall<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
+}
+
+export interface IMonsterStorageClient {
+  Store(request: MonsterStorage_fbs.Monster, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
+  Store(request: MonsterStorage_fbs.Monster, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
+  Store(request: MonsterStorage_fbs.Monster, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
+  Retrieve(request: MonsterStorage_fbs.Stat, metadata: grpc.Metadata): grpc.ClientReadableStream<MonsterStorage_fbs.Monster>;
+  Retrieve(request: MonsterStorage_fbs.Stat, options: Partial<grpc.CallOptions>): grpc.ClientReadableStream<MonsterStorage_fbs.Monster>;
+  GetMaxHitPoint(callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
+  GetMaxHitPoint(metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
+  GetMaxHitPoint(options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
+  GetMaxHitPoint(metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
+  GetMinMaxHitPoints(): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
+  GetMinMaxHitPoints(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
+  GetMinMaxHitPoints(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
+}
+
+export class MonsterStorageClient extends grpc.Client implements IMonsterStorageClient {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);  public Store(request: MonsterStorage_fbs.Monster, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
+  public Store(request: MonsterStorage_fbs.Monster, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
+  public Store(request: MonsterStorage_fbs.Monster, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
+  public Retrieve(request: MonsterStorage_fbs.Stat, metadata: grpc.Metadata): grpc.ClientReadableStream<MonsterStorage_fbs.Monster>;
+  public Retrieve(request: MonsterStorage_fbs.Stat, options: Partial<grpc.CallOptions>): grpc.ClientReadableStream<MonsterStorage_fbs.Monster>;
+  public GetMaxHitPoint(callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
+  public GetMaxHitPoint(metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
+  public GetMaxHitPoint(options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
+  public GetMaxHitPoint(metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
+  public GetMinMaxHitPoints(): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
+  public GetMinMaxHitPoints(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
+  public GetMinMaxHitPoints(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
+}
+

tests/monster_test_grpc.js

@@ -0,0 +1,79 @@
+// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***
+import { flatbuffers } from 'flatbuffers';
+import *  as MonsterStorage_fbs from './monster_test_generated';
+
+var grpc = require('grpc');
+
+function serialize_Stat(buffer_args) {
+  if (!(buffer_args instanceof MonsterStorage_fbs.Stat)) {
+    throw new Error('Expected argument of type MonsterStorage_fbs.Stat');
+  }
+  return buffer_args.serialize();
+}
+
+function deserialize_Stat(buffer) {
+  return MonsterStorage_fbs.Stat.getRootAsStat(new flatbuffers.ByteBuffer(buffer))
+}
+
+
+function serialize_Monster(buffer_args) {
+  if (!(buffer_args instanceof MonsterStorage_fbs.Monster)) {
+    throw new Error('Expected argument of type MonsterStorage_fbs.Monster');
+  }
+  return buffer_args.serialize();
+}
+
+function deserialize_Monster(buffer) {
+  return MonsterStorage_fbs.Monster.getRootAsMonster(new flatbuffers.ByteBuffer(buffer))
+}
+
+
+
+
+var MonsterStorageService = exports.MonsterStorageService = {
+  Store: {
+    path: '/MyGame.Example.MonsterStorage/Store',
+    requestStream: false,
+    responseStream: false,
+    requestType: flatbuffers.ByteBuffer,
+    responseType: MonsterStorage_fbs.Stat,
+    requestSerialize: serialize_Monster,
+    requestDeserialize: deserialize_Monster,
+    responseSerialize: serialize_Stat,
+    responseDeserialize: deserialize_Stat,
+  },
+  Retrieve: {
+    path: '/MyGame.Example.MonsterStorage/Retrieve',
+    requestStream: false,
+    responseStream: true,
+    requestType: flatbuffers.ByteBuffer,
+    responseType: MonsterStorage_fbs.Monster,
+    requestSerialize: serialize_Stat,
+    requestDeserialize: deserialize_Stat,
+    responseSerialize: serialize_Monster,
+    responseDeserialize: deserialize_Monster,
+  },
+  GetMaxHitPoint: {
+    path: '/MyGame.Example.MonsterStorage/GetMaxHitPoint',
+    requestStream: true,
+    responseStream: false,
+    requestType: flatbuffers.ByteBuffer,
+    responseType: MonsterStorage_fbs.Stat,
+    requestSerialize: serialize_Monster,
+    requestDeserialize: deserialize_Monster,
+    responseSerialize: serialize_Stat,
+    responseDeserialize: deserialize_Stat,
+  },
+  GetMinMaxHitPoints: {
+    path: '/MyGame.Example.MonsterStorage/GetMinMaxHitPoints',
+    requestStream: true,
+    responseStream: true,
+    requestType: flatbuffers.ByteBuffer,
+    responseType: MonsterStorage_fbs.Stat,
+    requestSerialize: serialize_Monster,
+    requestDeserialize: deserialize_Monster,
+    responseSerialize: serialize_Stat,
+    responseDeserialize: deserialize_Stat,
+  },
+};
+exports.MonsterStorageClient = grpc.makeGenericClientConstructor(MonsterStorageService);