Bump flatbuffers to v24.3.25 version (#6968)

third_party/flatbuffers/grpc/examples/README.md

@@ -0,0 +1,35 @@
+## Languages known issues
+
+### Python
+
+- Assert the type required in your server/client since python is able to receive `Bytes array` or `utf8 strings`.
+
+```python
+def SayHello(self, request, context):
+    # request might be a byte array or a utf8 string
+
+    r = HelloRequest.HelloRequest().GetRootAs(request, 0)
+    reply = "Unknown"
+    if r.Name():
+        reply = r.Name()
+    # Issues might happen if type checking isnt present.
+    # thus encoding it as a `reply.decode('UTF-8')`
+    return build_reply("welcome " + reply.decode('UTF-8'))
+
+```
+
+This can be prevented by making sure all the requests coming to/from python are `Bytes array`
+
+```python
+def say_hello(stub, builder):
+    hello_request = bytes(builder.Output())
+    reply = stub.SayHello(hello_request)
+    r = HelloReply.HelloReply.GetRootAs(reply)
+    print(r.Message())
+```
+
+### Go
+
+- Always requires the `content-type` of the payload to be set to `application/grpc+flatbuffers`
+
+example: `.SayHello(ctx, b, grpc.CallContentSubtype("flatbuffers"))`

third_party/flatbuffers/grpc/examples/go/format.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+#
+# Copyright 2021 Google Inc. All rights reserved.
+#
+# 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.
+
+set -e
+
+
+format_greeter() {
+  cd greeter
+
+  # Format client
+  cd client
+  gofmt -w .
+  cd ..
+
+  # Format server
+  cd server
+  gofmt -w .
+  cd ..
+
+  cd ..
+}
+
+format_greeter

third_party/flatbuffers/grpc/examples/go/greeter/.gitignore

@@ -0,0 +1,2 @@
+**/server
+**/client

third_party/flatbuffers/grpc/examples/go/greeter/README.md

@@ -0,0 +1,25 @@
+# Go Greeter example
+
+## Project Structure
+
+    .
+    ├── server                   # Server module
+    ├── client                   # Client module
+    ├── models                   # Flatbuffers models & main grpc code.
+    └── README.md
+
+## How to run Server:
+
+- `cd server`
+
+- `go clean`
+
+- `go run main.go`
+
+## How to run Client:
+
+- `cd client`
+
+- `go clean`
+
+- `go run main.go --name NAME`

third_party/flatbuffers/grpc/examples/go/greeter/client/go.mod

@@ -0,0 +1,11 @@
+module github.com/google/flatbuffers/grpc/examples/go/greeter/client
+
+go 1.15
+
+replace github.com/google/flatbuffers/grpc/examples/go/greeter/models v0.0.0 => ../models
+
+require (
+	github.com/google/flatbuffers v2.0.8+incompatible
+	github.com/google/flatbuffers/grpc/examples/go/greeter/models v0.0.0
+	google.golang.org/grpc v1.56.3
+)

third_party/flatbuffers/grpc/examples/go/greeter/client/main.go

@@ -0,0 +1,78 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"time"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+
+	models "github.com/google/flatbuffers/grpc/examples/go/greeter/models"
+)
+
+var (
+	addr = "3000"
+	name = flag.String("name", "Flatbuffers", "name to be sent to server :D")
+)
+
+func printSayHello(client models.GreeterClient, name string) {
+	log.Printf("Name to be sent (%s)", name)
+	b := flatbuffers.NewBuilder(0)
+	i := b.CreateString(name)
+	models.HelloRequestStart(b)
+	models.HelloRequestAddName(b, i)
+	b.Finish(models.HelloRequestEnd(b))
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	request, err := client.SayHello(ctx, b, grpc.CallContentSubtype("flatbuffers"))
+	if err != nil {
+		log.Fatalf("%v.SayHello(_) = _, %v: ", client, err)
+	}
+	log.Printf("server said %q", request.Message())
+}
+
+func printSayManyHello(client models.GreeterClient, name string) {
+	log.Printf("Name to be sent (%s)", name)
+	b := flatbuffers.NewBuilder(0)
+	i := b.CreateString(name)
+	models.HelloRequestStart(b)
+	models.HelloRequestAddName(b, i)
+	b.Finish(models.HelloRequestEnd(b))
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	stream, err := client.SayManyHellos(ctx, b, grpc.CallContentSubtype("flatbuffers"))
+	if err != nil {
+		log.Fatalf("%v.SayManyHellos(_) = _, %v", client, err)
+	}
+	for {
+		request, err := stream.Recv()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			log.Fatalf("%v.SayManyHellos(_) = _, %v", client, err)
+		}
+		log.Printf("server said %q", request.Message())
+	}
+}
+
+func main() {
+	flag.Parse()
+	conn, err := grpc.Dial(fmt.Sprintf("localhost:%d", 3000),
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithDefaultCallOptions(grpc.ForceCodec(flatbuffers.FlatbuffersCodec{})))
+	if err != nil {
+		log.Fatalf("fail to dial: %v", err)
+	}
+	defer conn.Close()
+	client := models.NewGreeterClient(conn)
+	printSayHello(client, *name)
+	printSayManyHello(client, *name)
+}

third_party/flatbuffers/grpc/examples/go/greeter/models/Greeter_grpc.go

@@ -0,0 +1,158 @@
+//Generated by gRPC Go plugin
+//If you make any local changes, they will be lost
+//source: greeter
+
+package models
+
+import (
+	context "context"
+	flatbuffers "github.com/google/flatbuffers/go"
+	grpc "google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+// Client API for Greeter service
+type GreeterClient interface {
+	SayHello(ctx context.Context, in *flatbuffers.Builder,
+		opts ...grpc.CallOption) (*HelloReply, error)
+	SayManyHellos(ctx context.Context, in *flatbuffers.Builder,
+		opts ...grpc.CallOption) (Greeter_SayManyHellosClient, error)
+}
+
+type greeterClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewGreeterClient(cc grpc.ClientConnInterface) GreeterClient {
+	return &greeterClient{cc}
+}
+
+func (c *greeterClient) SayHello(ctx context.Context, in *flatbuffers.Builder,
+	opts ...grpc.CallOption) (*HelloReply, error) {
+	out := new(HelloReply)
+	err := c.cc.Invoke(ctx, "/models.Greeter/SayHello", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *greeterClient) SayManyHellos(ctx context.Context, in *flatbuffers.Builder,
+	opts ...grpc.CallOption) (Greeter_SayManyHellosClient, error) {
+	stream, err := c.cc.NewStream(ctx, &_Greeter_serviceDesc.Streams[0], "/models.Greeter/SayManyHellos", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &greeterSayManyHellosClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type Greeter_SayManyHellosClient interface {
+	Recv() (*HelloReply, error)
+	grpc.ClientStream
+}
+
+type greeterSayManyHellosClient struct {
+	grpc.ClientStream
+}
+
+func (x *greeterSayManyHellosClient) Recv() (*HelloReply, error) {
+	m := new(HelloReply)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for Greeter service
+type GreeterServer interface {
+	SayHello(context.Context, *HelloRequest) (*flatbuffers.Builder, error)
+	SayManyHellos(*HelloRequest, Greeter_SayManyHellosServer) error
+	mustEmbedUnimplementedGreeterServer()
+}
+
+type UnimplementedGreeterServer struct {
+}
+
+func (UnimplementedGreeterServer) SayHello(context.Context, *HelloRequest) (*flatbuffers.Builder, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
+}
+
+func (UnimplementedGreeterServer) SayManyHellos(*HelloRequest, Greeter_SayManyHellosServer) error {
+	return status.Errorf(codes.Unimplemented, "method SayManyHellos not implemented")
+}
+
+func (UnimplementedGreeterServer) mustEmbedUnimplementedGreeterServer() {}
+
+type UnsafeGreeterServer interface {
+	mustEmbedUnimplementedGreeterServer()
+}
+
+func RegisterGreeterServer(s grpc.ServiceRegistrar, srv GreeterServer) {
+	s.RegisterService(&_Greeter_serviceDesc, srv)
+}
+
+func _Greeter_SayHello_Handler(srv interface{}, ctx context.Context,
+	dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(HelloRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GreeterServer).SayHello(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/models.Greeter/SayHello",
+	}
+
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+func _Greeter_SayManyHellos_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(HelloRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(GreeterServer).SayManyHellos(m, &greeterSayManyHellosServer{stream})
+}
+
+type Greeter_SayManyHellosServer interface {
+	Send(*flatbuffers.Builder) error
+	grpc.ServerStream
+}
+
+type greeterSayManyHellosServer struct {
+	grpc.ServerStream
+}
+
+func (x *greeterSayManyHellosServer) Send(m *flatbuffers.Builder) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+var _Greeter_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "models.Greeter",
+	HandlerType: (*GreeterServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "SayHello",
+			Handler:    _Greeter_SayHello_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "SayManyHellos",
+			Handler:       _Greeter_SayManyHellos_Handler,
+			ServerStreams: true,
+		},
+	},
+}

third_party/flatbuffers/grpc/examples/go/greeter/models/HelloReply.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package models
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type HelloReply struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsHelloReply(buf []byte, offset flatbuffers.UOffsetT) *HelloReply {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &HelloReply{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishHelloReplyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsHelloReply(buf []byte, offset flatbuffers.UOffsetT) *HelloReply {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &HelloReply{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedHelloReplyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *HelloReply) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *HelloReply) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *HelloReply) Message() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func HelloReplyStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func HelloReplyAddMessage(builder *flatbuffers.Builder, message flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(message), 0)
+}
+func HelloReplyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

third_party/flatbuffers/grpc/examples/go/greeter/models/HelloRequest.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package models
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type HelloRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsHelloRequest(buf []byte, offset flatbuffers.UOffsetT) *HelloRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &HelloRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishHelloRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsHelloRequest(buf []byte, offset flatbuffers.UOffsetT) *HelloRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &HelloRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedHelloRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *HelloRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *HelloRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *HelloRequest) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func HelloRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func HelloRequestAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func HelloRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

third_party/flatbuffers/grpc/examples/go/greeter/models/go.mod

@@ -0,0 +1,8 @@
+module github.com/google/flatbuffers/grpc/examples/go/greeter/models
+
+go 1.15
+
+require (
+	github.com/google/flatbuffers v2.0.8+incompatible
+	google.golang.org/grpc v1.56.3
+)

third_party/flatbuffers/grpc/examples/go/greeter/server/go.mod

@@ -0,0 +1,11 @@
+module github.com/google/flatbuffers/grpc/examples/go/greeter/server
+
+go 1.15
+
+replace github.com/google/flatbuffers/grpc/examples/go/greeter/models v0.0.0 => ../models
+
+require (
+	github.com/google/flatbuffers v2.0.8+incompatible
+	github.com/google/flatbuffers/grpc/examples/go/greeter/models v0.0.0
+	google.golang.org/grpc v1.56.3
+)

third_party/flatbuffers/grpc/examples/go/greeter/server/main.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+	models "github.com/google/flatbuffers/grpc/examples/go/greeter/models"
+	"google.golang.org/grpc"
+)
+
+var (
+	greetings = [...]string{"Hi", "Hallo", "Ciao"}
+)
+
+type greeterServer struct {
+	models.UnimplementedGreeterServer
+}
+
+func (s *greeterServer) SayHello(ctx context.Context, request *models.HelloRequest) (*flatbuffers.Builder, error) {
+	v := request.Name()
+	var m string
+	if v == nil {
+		m = "Unknown"
+	} else {
+		m = string(v)
+	}
+	b := flatbuffers.NewBuilder(0)
+	idx := b.CreateString("welcome " + m)
+	models.HelloReplyStart(b)
+	models.HelloReplyAddMessage(b, idx)
+	b.Finish(models.HelloReplyEnd(b))
+	return b, nil
+}
+
+func (s *greeterServer) SayManyHellos(request *models.HelloRequest, stream models.Greeter_SayManyHellosServer) error {
+	v := request.Name()
+	var m string
+	if v == nil {
+		m = "Unknown"
+	} else {
+		m = string(v)
+	}
+	b := flatbuffers.NewBuilder(0)
+
+	for _, greeting := range greetings {
+		idx := b.CreateString(greeting + " " + m)
+		models.HelloReplyStart(b)
+		models.HelloReplyAddMessage(b, idx)
+		b.Finish(models.HelloReplyEnd(b))
+		if err := stream.Send(b); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func newServer() *greeterServer {
+	s := &greeterServer{}
+	return s
+}
+
+func main() {
+	lis, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", 3000))
+	if err != nil {
+		log.Fatalf("failed to listen: %v", err)
+	}
+	codec := &flatbuffers.FlatbuffersCodec{}
+	grpcServer := grpc.NewServer(grpc.ForceServerCodec(codec))
+	models.RegisterGreeterServer(grpcServer, newServer())
+	if err := grpcServer.Serve(lis); err != nil {
+		fmt.Print(err)
+		panic(err)
+	}
+}

third_party/flatbuffers/grpc/examples/greeter.fbs

@@ -0,0 +1,14 @@
+namespace models;
+
+table HelloReply {
+  message:string;
+}
+
+table HelloRequest {
+  name:string;
+}
+
+rpc_service Greeter {
+  SayHello(HelloRequest):HelloReply;
+  SayManyHellos(HelloRequest):HelloReply (streaming: "server");
+}

third_party/flatbuffers/grpc/examples/python/greeter/README.md

@@ -0,0 +1,12 @@
+# Python Greeter example
+
+## Prerequisite
+
+- You need to have grpc python installed on your device `pip install grpcio`
+## How to run Server:
+
+- `python server.py ${PORT}`
+
+## How to run Client:
+
+- `python client.py ${PORT} ${NAME}`

third_party/flatbuffers/grpc/examples/python/greeter/client.py

@@ -0,0 +1,40 @@
+import sys		
+import argparse
+import grpc
+
+sys.path.insert(0, '../../../../../flatbuffers/python')
+
+import flatbuffers
+from models import HelloReply, HelloRequest, greeter_grpc_fb
+
+parser = argparse.ArgumentParser()
+parser.add_argument("port", help="server port to connect to", default=3000)
+parser.add_argument("name", help="name to be sent to server", default="flatbuffers")
+
+def say_hello(stub, hello_request):
+    reply = stub.SayHello(hello_request)
+    r = HelloReply.HelloReply.GetRootAs(reply)
+    print(r.Message())
+
+def say_many_hellos(stub, hello_request):
+    greetings = stub.SayManyHellos(hello_request)
+    for greeting in greetings:
+        r = HelloReply.HelloReply.GetRootAs(greeting)
+        print(r.Message())
+
+def main():
+    args = parser.parse_args()
+
+    with grpc.insecure_channel('localhost:' + args.port) as channel:
+        builder = flatbuffers.Builder()		
+        ind = builder.CreateString(args.name)
+        HelloRequest.HelloRequestStart(builder)
+        HelloRequest.HelloRequestAddName(builder, ind)
+        root = HelloRequest.HelloRequestEnd(builder)
+        builder.Finish(root)
+        output = bytes(builder.Output())
+        stub = greeter_grpc_fb.GreeterStub(channel)
+        say_hello(stub, output)
+        say_many_hellos(stub, output)
+
+main()

third_party/flatbuffers/grpc/examples/python/greeter/models/HelloReply.py

@@ -0,0 +1,50 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: models
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class HelloReply(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = HelloReply()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsHelloReply(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # HelloReply
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # HelloReply
+    def Message(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def HelloReplyStart(builder):
+    builder.StartObject(1)
+
+def Start(builder):
+    HelloReplyStart(builder)
+
+def HelloReplyAddMessage(builder, message):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
+
+def AddMessage(builder, message):
+    HelloReplyAddMessage(builder, message)
+
+def HelloReplyEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return HelloReplyEnd(builder)

third_party/flatbuffers/grpc/examples/python/greeter/models/HelloRequest.py

@@ -0,0 +1,50 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: models
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class HelloRequest(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = HelloRequest()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsHelloRequest(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # HelloRequest
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # HelloRequest
+    def Name(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def HelloRequestStart(builder):
+    builder.StartObject(1)
+
+def Start(builder):
+    HelloRequestStart(builder)
+
+def HelloRequestAddName(builder, name):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def AddName(builder, name):
+    HelloRequestAddName(builder, name)
+
+def HelloRequestEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return HelloRequestEnd(builder)

third_party/flatbuffers/grpc/examples/python/greeter/models/greeter_grpc_fb.py

@@ -0,0 +1,52 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+
+import grpc
+
+class GreeterStub(object):
+  """ Interface exported by the server. """  
+  
+  def __init__(self, channel):
+    """ Constructor. 
+    
+    Args: 
+    channel: A grpc.Channel. 
+    """
+    
+    self.SayHello = channel.unary_unary(
+      "/models.Greeter/SayHello"
+      )
+    
+    self.SayManyHellos = channel.unary_stream(
+      "/models.Greeter/SayManyHellos"
+      )
+    
+
+class GreeterServicer(object):
+  """ Interface exported by the server. """  
+  
+  def SayHello(self, request, context):
+    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+    context.set_details('Method not implemented!')
+    raise NotImplementedError('Method not implemented!')
+  
+  
+  def SayManyHellos(self, request, context):
+    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+    context.set_details('Method not implemented!')
+    raise NotImplementedError('Method not implemented!')
+  
+  
+
+def add_GreeterServicer_to_server(servicer, server):
+  rpc_method_handlers = {
+    'SayHello': grpc.unary_unary_rpc_method_handler(
+      servicer.SayHello
+    ),
+    'SayManyHellos': grpc.unary_stream_rpc_method_handler(
+      servicer.SayManyHellos
+    ),
+  }
+  generic_handler = grpc.method_handlers_generic_handler(
+    'models.Greeter', rpc_method_handlers)
+  server.add_generic_rpc_handlers((generic_handler,))
+

third_party/flatbuffers/grpc/examples/python/greeter/server.py

@@ -0,0 +1,57 @@
+from concurrent import futures
+import sys		
+import argparse
+import grpc
+
+sys.path.insert(0, '../../../../../flatbuffers/python')
+
+import flatbuffers
+from models import HelloReply, HelloRequest, greeter_grpc_fb
+
+parser = argparse.ArgumentParser()
+parser.add_argument("port", help="server on port", default=3000)
+
+def build_reply(message):
+    builder = flatbuffers.Builder()		
+    ind = builder.CreateString(message)
+    HelloReply.HelloReplyStart(builder)
+    HelloReply.HelloReplyAddMessage(builder, ind)
+    root = HelloReply.HelloReplyEnd(builder)
+    builder.Finish(root)
+    return bytes(builder.Output())
+
+class GreeterServicer(greeter_grpc_fb.GreeterServicer):
+
+    def __init__(self):
+        self.greetings = ["Hi", "Hallo", "Ciao"]
+
+    def SayHello(self, request, context):
+        r = HelloRequest.HelloRequest().GetRootAs(request, 0)
+        reply = "Unknown"
+        if r.Name():
+            reply = r.Name()
+        return build_reply("welcome " + reply.decode('UTF-8'))
+
+    def SayManyHellos(self, request, context):
+        r = HelloRequest.HelloRequest().GetRootAs(request, 0)
+        reply = "Unknown"
+        if r.Name():
+            reply = r.Name()
+
+        for greeting in self.greetings:
+            print(type(reply))
+            yield build_reply(greeting + " " + reply.decode('UTF-8'))
+        
+
+def serve():
+    args = parser.parse_args()
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+    greeter_grpc_fb.add_GreeterServicer_to_server(
+        GreeterServicer(), server
+    )
+    server.add_insecure_port('[::]:' + args.port)
+    server.start()
+    server.wait_for_termination()
+
+if __name__ == '__main__':
+    serve()

third_party/flatbuffers/grpc/examples/swift/Greeter/Package.swift

@@ -0,0 +1,58 @@
+// swift-tools-version:5.1
+/*
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+
+import PackageDescription
+
+let package = Package(
+  name: "Greeter",
+  platforms: [
+    .iOS(.v11),
+    .macOS(.v10_14),
+  ],
+  dependencies: [
+    .package(path: "../../../../swift"),
+    .package(url: "https://github.com/grpc/grpc-swift.git", from: "1.0.0"),
+  ],
+  targets: [
+    // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+    // Targets can depend on other targets in this package, and on products in packages which this package depends on.
+    .target(
+      name: "Model",
+      dependencies: [
+        "GRPC",
+        "FlatBuffers",
+      ],
+      path: "Sources/Model"),
+
+    // Client for the Greeter example
+    .target(
+      name: "Client",
+      dependencies: [
+        "GRPC",
+        "Model",
+      ],
+      path: "Sources/client"),
+
+    // Server for the Greeter example
+    .target(
+      name: "Server",
+      dependencies: [
+        "GRPC",
+        "Model",
+      ],
+      path: "Sources/server"),
+  ])

third_party/flatbuffers/grpc/examples/swift/Greeter/README.md

@@ -0,0 +1,7 @@
+# FlatBuffers.GRPC.Swift
+
+The following is Swift example on how GRPC would be with Swift Flatbuffers, you can simply run the following commands:
+
+`swift run Server`
+
+`swift run Client {port} {name}`

third_party/flatbuffers/grpc/examples/swift/Greeter/Sources/Model/greeter.grpc.swift

@@ -0,0 +1,145 @@
+// Generated GRPC code for FlatBuffers swift!
+/// The following code is generated by the Flatbuffers library which might not be in sync with grpc-swift
+/// in case of an issue please open github issue, though it would be maintained
+
+// swiftlint:disable all
+// swiftformat:disable all
+
+import Foundation
+import GRPC
+import NIO
+import NIOHTTP1
+import FlatBuffers
+
+public protocol GRPCFlatBufPayload: GRPCPayload, FlatBufferGRPCMessage {}
+public extension GRPCFlatBufPayload {
+  init(serializedByteBuffer: inout NIO.ByteBuffer) throws {
+    self.init(byteBuffer: FlatBuffers.ByteBuffer(contiguousBytes: serializedByteBuffer.readableBytesView, count: serializedByteBuffer.readableBytes))
+  }
+  func serialize(into buffer: inout NIO.ByteBuffer) throws {
+    let buf = UnsafeRawBufferPointer(start: self.rawPointer, count: Int(self.size))
+    buffer.writeBytes(buf)
+  }
+}
+extension Message: GRPCFlatBufPayload {}
+
+/// Usage: instantiate models_GreeterServiceClient, then call methods of this protocol to make API calls.
+public protocol models_GreeterClientProtocol: GRPCClient {
+
+  var serviceName: String { get }
+
+  var interceptors: models_GreeterClientInterceptorFactoryProtocol? { get }
+
+  func SayHello(
+    _ request: Message<models_HelloRequest>
+    , callOptions: CallOptions?
+  ) -> UnaryCall<Message<models_HelloRequest>, Message<models_HelloReply>>
+
+  func SayManyHellos(
+    _ request: Message<models_HelloRequest>
+    , callOptions: CallOptions?,
+    handler: @escaping (Message<models_HelloReply>) -> Void
+  ) -> ServerStreamingCall<Message<models_HelloRequest>, Message<models_HelloReply>>
+
+}
+
+extension models_GreeterClientProtocol {
+
+  public var serviceName: String { "models.Greeter" }
+
+  public func SayHello(
+    _ request: Message<models_HelloRequest>
+    , callOptions: CallOptions? = nil
+  ) -> UnaryCall<Message<models_HelloRequest>, Message<models_HelloReply>> {
+    return self.makeUnaryCall(
+      path: "/models.Greeter/SayHello",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeSayHelloInterceptors() ?? []
+    )
+  }
+
+  public func SayManyHellos(
+    _ request: Message<models_HelloRequest>
+    , callOptions: CallOptions? = nil,
+    handler: @escaping (Message<models_HelloReply>) -> Void
+  ) -> ServerStreamingCall<Message<models_HelloRequest>, Message<models_HelloReply>> {
+    return self.makeServerStreamingCall(
+      path: "/models.Greeter/SayManyHellos",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeSayManyHellosInterceptors() ?? [],
+      handler: handler
+    )
+  }
+}
+
+public protocol models_GreeterClientInterceptorFactoryProtocol {
+  /// - Returns: Interceptors to use when invoking 'SayHello'.
+  func makeSayHelloInterceptors() -> [ClientInterceptor<Message<models_HelloRequest>, Message<models_HelloReply>>]
+
+  /// - Returns: Interceptors to use when invoking 'SayManyHellos'.
+  func makeSayManyHellosInterceptors() -> [ClientInterceptor<Message<models_HelloRequest>, Message<models_HelloReply>>]
+
+}
+
+public final class models_GreeterServiceClient: models_GreeterClientProtocol {
+  public let channel: GRPCChannel
+  public var defaultCallOptions: CallOptions
+  public var interceptors: models_GreeterClientInterceptorFactoryProtocol?
+
+  public init(
+    channel: GRPCChannel,
+    defaultCallOptions: CallOptions = CallOptions(),
+    interceptors: models_GreeterClientInterceptorFactoryProtocol? = nil
+  ) {
+    self.channel = channel
+    self.defaultCallOptions = defaultCallOptions
+    self.interceptors = interceptors
+  }
+}
+
+public protocol models_GreeterProvider: CallHandlerProvider {
+  var interceptors: models_GreeterServerInterceptorFactoryProtocol? { get }
+  func SayHello(request: Message<models_HelloRequest>, context: StatusOnlyCallContext) -> EventLoopFuture<Message<models_HelloReply>>
+  func SayManyHellos(request: Message<models_HelloRequest>, context: StreamingResponseCallContext<Message<models_HelloReply>>) -> EventLoopFuture<GRPCStatus>
+}
+
+public extension models_GreeterProvider {
+
+  var serviceName: Substring { return "models.Greeter" }
+
+  func handle(method name: Substring, context: CallHandlerContext) -> GRPCServerHandlerProtocol? {
+    switch name {
+    case "SayHello":
+    return UnaryServerHandler(
+      context: context,
+      requestDeserializer: GRPCPayloadDeserializer<Message<models_HelloRequest>>(),
+      responseSerializer: GRPCPayloadSerializer<Message<models_HelloReply>>(),
+      interceptors: self.interceptors?.makeSayHelloInterceptors() ?? [],
+      userFunction: self.SayHello(request:context:))
+
+    case "SayManyHellos":
+    return ServerStreamingServerHandler(
+      context: context,
+      requestDeserializer: GRPCPayloadDeserializer<Message<models_HelloRequest>>(),
+      responseSerializer: GRPCPayloadSerializer<Message<models_HelloReply>>(),
+      interceptors: self.interceptors?.makeSayManyHellosInterceptors() ?? [],
+      userFunction: self.SayManyHellos(request:context:))
+
+    default: return nil;
+    }
+  }
+
+}
+
+public protocol models_GreeterServerInterceptorFactoryProtocol {
+  /// - Returns: Interceptors to use when handling 'SayHello'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeSayHelloInterceptors() -> [ServerInterceptor<Message<models_HelloRequest>, Message<models_HelloReply>>]
+
+  /// - Returns: Interceptors to use when handling 'SayManyHellos'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeSayManyHellosInterceptors() -> [ServerInterceptor<Message<models_HelloRequest>, Message<models_HelloReply>>]
+
+}

third_party/flatbuffers/grpc/examples/swift/Greeter/Sources/Model/greeter_generated.swift

@@ -0,0 +1,100 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public struct models_HelloReply: FlatBufferObject, Verifiable {
+
+  static func validateVersion() { FlatBuffersVersion_24_3_25() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case message = 4
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var message: String? { let o = _accessor.offset(VTOFFSET.message.v); return o == 0 ? nil : _accessor.string(at: o) }
+  public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.message.v) }
+  public static func startHelloReply(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+  public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VTOFFSET.message.p) }
+  public static func endHelloReply(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createHelloReply(
+    _ fbb: inout FlatBufferBuilder,
+    messageOffset message: Offset = Offset()
+  ) -> Offset {
+    let __start = models_HelloReply.startHelloReply(&fbb)
+    models_HelloReply.add(message: message, &fbb)
+    return models_HelloReply.endHelloReply(&fbb, start: __start)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.message.p, fieldName: "message", required: false, type: ForwardOffset<String>.self)
+    _v.finish()
+  }
+}
+
+extension models_HelloReply: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case message = "message"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encodeIfPresent(message, forKey: .message)
+  }
+}
+
+public struct models_HelloRequest: FlatBufferObject, Verifiable {
+
+  static func validateVersion() { FlatBuffersVersion_24_3_25() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case name = 4
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var name: String? { let o = _accessor.offset(VTOFFSET.name.v); return o == 0 ? nil : _accessor.string(at: o) }
+  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.name.v) }
+  public static func startHelloRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
+  public static func endHelloRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createHelloRequest(
+    _ fbb: inout FlatBufferBuilder,
+    nameOffset name: Offset = Offset()
+  ) -> Offset {
+    let __start = models_HelloRequest.startHelloRequest(&fbb)
+    models_HelloRequest.add(name: name, &fbb)
+    return models_HelloRequest.endHelloRequest(&fbb, start: __start)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: false, type: ForwardOffset<String>.self)
+    _v.finish()
+  }
+}
+
+extension models_HelloRequest: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case name = "name"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encodeIfPresent(name, forKey: .name)
+  }
+}
+

third_party/flatbuffers/grpc/examples/swift/Greeter/Sources/client/main.swift

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2023 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+
+import FlatBuffers
+import GRPC
+import Logging
+import Model
+import NIO
+
+// Quieten the logs.
+LoggingSystem.bootstrap {
+  var handler = StreamLogHandler.standardOutput(label: $0)
+  handler.logLevel = .critical
+  return handler
+}
+
+func greet(name: String, client greeter: models_GreeterServiceClient) {
+  // Form the request with the name, if one was provided.
+  var builder = FlatBufferBuilder()
+  let nameOff = builder.create(string: name)
+  let root = models_HelloRequest.createHelloRequest(
+    &builder,
+    nameOffset: nameOff)
+  builder.finish(offset: root)
+
+  // Make the RPC call to the server.
+  let sayHello = greeter
+    .SayHello(Message<models_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()
+    print("Greeter SayHello received: \(response.object.message ?? "Unknown")")
+  } catch {
+    print("Greeter failed: \(error)")
+  }
+
+  let surname = builder.create(string: name)
+  let manyRoot = models_HelloRequest.createHelloRequest(
+    &builder,
+    nameOffset: surname)
+  builder.finish(offset: manyRoot)
+
+  let call = greeter.SayManyHellos(Message(builder: &builder)) { message in
+    print(
+      "Greeter SayManyHellos received: \(message.object.message  ?? "Unknown")")
+  }
+
+  let status = try! call.status.recover { _ in .processingError }.wait()
+  if status.code != .ok {
+    print("RPC failed: \(status)")
+  }
+}
+
+func main(args: [String]) {
+  // arg0 (dropped) is the program name. We expect arg1 to be the port, and arg2 (optional) to be
+  // the name sent in the request.
+  let arg1 = args.dropFirst(1).first
+  let arg2 = args.dropFirst(2).first
+
+  switch (arg1.flatMap(Int.init), arg2) {
+  case (.none, _):
+    print("Usage: PORT [NAME]")
+    exit(1)
+
+  case let (.some(port), name):
+    // Setup an `EventLoopGroup` for the connection to run on.
+    //
+    // See: https://github.com/apple/swift-nio#eventloops-and-eventloopgroups
+    let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+
+    // Make sure the group is shutdown when we're done with it.
+    defer {
+      try! group.syncShutdownGracefully()
+    }
+
+    // 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 = models_GreeterServiceClient(channel: channel)
+
+    // Do the greeting.
+    greet(name: name ?? "FlatBuffers!", client: greeter)
+  }
+}
+
+main(args: CommandLine.arguments)

third_party/flatbuffers/grpc/examples/swift/Greeter/Sources/server/main.swift

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2023 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+
+import FlatBuffers
+import GRPC
+import Logging
+import Model
+import NIO
+
+class Greeter: models_GreeterProvider {
+
+  var interceptors: models_GreeterServerInterceptorFactoryProtocol?
+
+  let greetings: [String]
+
+  init() {
+    greetings = ["Hi", "Hallo", "Ciao"]
+  }
+
+  func SayHello(
+    request: Message<models_HelloRequest>,
+    context: StatusOnlyCallContext)
+    -> EventLoopFuture<Message<models_HelloReply>>
+  {
+    let recipient = request.object.name ?? "Stranger"
+
+    var builder = FlatBufferBuilder()
+    let off = builder.create(string: "Hello \(recipient)")
+    let root = models_HelloReply.createHelloReply(&builder, messageOffset: off)
+    builder.finish(offset: root)
+    return context.eventLoop
+      .makeSucceededFuture(Message<models_HelloReply>(builder: &builder))
+  }
+
+  func SayManyHellos(
+    request: Message<models_HelloRequest>,
+    context: StreamingResponseCallContext<Message<models_HelloReply>>)
+    -> EventLoopFuture<GRPCStatus>
+  {
+    for name in greetings {
+      var builder = FlatBufferBuilder()
+      let off = builder
+        .create(string: "\(name) \(request.object.name ?? "Unknown")")
+      let root = models_HelloReply.createHelloReply(
+        &builder,
+        messageOffset: off)
+      builder.finish(offset: root)
+      _ = context.sendResponse(Message<models_HelloReply>(builder: &builder))
+    }
+    return context.eventLoop.makeSucceededFuture(.ok)
+  }
+}
+
+// Quieten the logs.
+LoggingSystem.bootstrap {
+  var handler = StreamLogHandler.standardOutput(label: $0)
+  handler.logLevel = .critical
+  return handler
+}
+
+let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+defer {
+  try! group.syncShutdownGracefully()
+}
+
+// Create some configuration for the server:
+let configuration = Server.Configuration(
+  target: .hostAndPort("localhost", 0),
+  eventLoopGroup: group,
+  serviceProviders: [Greeter()])
+
+// Start the server and print its address once it has started.
+let server = Server.start(configuration: configuration)
+server.map {
+  $0.channel.localAddress
+}.whenSuccess { address in
+  print("server started on port \(address!.port!)")
+}
+
+// Wait on the server's `onClose` future to stop the program from exiting.
+_ = try server.flatMap {
+  $0.onClose
+}.wait()

third_party/flatbuffers/grpc/examples/ts/greeter/README.md

@@ -0,0 +1,13 @@
+# TS Greeter example
+
+The following is an example on how to run the TS grpc server. Make sure that you have `Typescript` installed
+
+you would need to run `npm run build` or simply use `npm install && tsc`
+
+## How to run Server:
+
+- `npm run server`
+
+## How to run Client:
+
+- `npm run client 3000`

third_party/flatbuffers/grpc/examples/ts/greeter/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "flatbuffers-js-grpc",
+  "version": "1.0.0",
+  "author": "mustii@mmk.one",
+  "scripts": {
+    "build": "npm install && tsc",
+    "client": "node dist/client.js",
+    "server": "node dist/server.js"
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.3.2",
+    "flatbuffers": "^2.0.0"
+  }
+}

third_party/flatbuffers/grpc/examples/ts/greeter/src/client.ts

@@ -0,0 +1,34 @@
+import * as grpc from '@grpc/grpc-js';
+import * as flatbuffers from 'flatbuffers';
+import { HelloReply } from './models/hello-reply';
+import { HelloRequest } from './models/hello-request';
+import { GreeterClient } from './greeter_grpc';
+
+async function main(PORT: Number, name: string) {
+    const client = new GreeterClient(`localhost:${PORT}`, grpc.credentials.createInsecure());
+    const builder = new flatbuffers.Builder();
+    const offset = builder.createString(name);
+    const root = HelloRequest.createHelloRequest(builder, offset);
+    builder.finish(root);
+    const buffer = HelloRequest.getRootAsHelloRequest(new flatbuffers.ByteBuffer(builder.asUint8Array()));
+
+    client.SayHello(buffer, (err, response) => {
+        console.log(response.message());
+    });
+
+    const data = client.SayManyHellos(buffer, null);
+
+    data.on('data', (data) => {
+        console.log(data.message());
+    });
+}
+
+const args = process.argv.slice(2)
+const PORT = Number(args[0]);
+const name: string = args[1] ?? "flatbuffers";
+
+if (PORT) {
+    main(PORT, name);
+} else {
+    throw new Error("Requires a valid port number.")
+}

third_party/flatbuffers/grpc/examples/ts/greeter/src/greeter.ts

@@ -0,0 +1,5 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+export * as models from './models.js';

third_party/flatbuffers/grpc/examples/ts/greeter/src/greeter_generated.ts

@@ -0,0 +1,4 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+export { HelloReply } from './models/hello-reply.js';
+export { HelloRequest } from './models/hello-request.js';

third_party/flatbuffers/grpc/examples/ts/greeter/src/greeter_grpc.d.ts

@@ -0,0 +1,56 @@
+// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***
+import * as flatbuffers from 'flatbuffers';
+import { HelloReply as models_HelloReply } from './models/hello-reply';
+import { HelloRequest as models_HelloRequest } from './models/hello-request';
+
+import * as grpc from '@grpc/grpc-js';
+
+interface IGreeterService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  SayHello: IGreeterService_ISayHello;
+  SayManyHellos: IGreeterService_ISayManyHellos;
+}
+interface IGreeterService_ISayHello extends grpc.MethodDefinition<models_HelloRequest, models_HelloReply> {
+  path: string; // /models.Greeter/SayHello
+  requestStream: boolean; // false
+  responseStream: boolean; // false
+  requestSerialize: grpc.serialize<models_HelloRequest>;
+  requestDeserialize: grpc.deserialize<models_HelloRequest>;
+  responseSerialize: grpc.serialize<models_HelloReply>;
+  responseDeserialize: grpc.deserialize<models_HelloReply>;
+}
+
+interface IGreeterService_ISayManyHellos extends grpc.MethodDefinition<models_HelloRequest, models_HelloReply> {
+  path: string; // /models.Greeter/SayManyHellos
+  requestStream: boolean; // false
+  responseStream: boolean; // true
+  requestSerialize: grpc.serialize<models_HelloRequest>;
+  requestDeserialize: grpc.deserialize<models_HelloRequest>;
+  responseSerialize: grpc.serialize<models_HelloReply>;
+  responseDeserialize: grpc.deserialize<models_HelloReply>;
+}
+
+
+export const GreeterService: IGreeterService;
+
+export interface IGreeterServer extends grpc.UntypedServiceImplementation {
+  SayHello: grpc.handleUnaryCall<models_HelloRequest, models_HelloReply>;
+  SayManyHellos: grpc.handleServerStreamingCall<models_HelloRequest, models_HelloReply>;
+}
+
+export interface IGreeterClient {
+  SayHello(request: models_HelloRequest, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;
+  SayHello(request: models_HelloRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;
+  SayHello(request: models_HelloRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;
+  SayManyHellos(request: models_HelloRequest, metadata: grpc.Metadata): grpc.ClientReadableStream<models_HelloReply>;
+  SayManyHellos(request: models_HelloRequest, options: Partial<grpc.CallOptions>): grpc.ClientReadableStream<models_HelloReply>;
+}
+
+export class GreeterClient extends grpc.Client implements IGreeterClient {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  public SayHello(request: models_HelloRequest, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;
+  public SayHello(request: models_HelloRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;
+  public SayHello(request: models_HelloRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;
+  public SayManyHellos(request: models_HelloRequest, metadata: grpc.Metadata): grpc.ClientReadableStream<models_HelloReply>;
+  public SayManyHellos(request: models_HelloRequest, options: Partial<grpc.CallOptions>): grpc.ClientReadableStream<models_HelloReply>;
+}
+

third_party/flatbuffers/grpc/examples/ts/greeter/src/greeter_grpc.js

@@ -0,0 +1,56 @@
+// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***
+import * as flatbuffers from 'flatbuffers';
+import { HelloReply as models_HelloReply } from './models/hello-reply';
+import { HelloRequest as models_HelloRequest } from './models/hello-request';
+
+var grpc = require('@grpc/grpc-js');
+
+function serialize_models_HelloReply(buffer_args) {
+  if (!(buffer_args instanceof models_HelloReply)) {
+    throw new Error('Expected argument of type HelloReply');
+  }
+  return Buffer.from(buffer_args.serialize());
+}
+
+function deserialize_models_HelloReply(buffer) {
+  return models_HelloReply.getRootAsHelloReply(new flatbuffers.ByteBuffer(buffer))
+}
+
+
+function serialize_models_HelloRequest(buffer_args) {
+  if (!(buffer_args instanceof models_HelloRequest)) {
+    throw new Error('Expected argument of type HelloRequest');
+  }
+  return Buffer.from(buffer_args.serialize());
+}
+
+function deserialize_models_HelloRequest(buffer) {
+  return models_HelloRequest.getRootAsHelloRequest(new flatbuffers.ByteBuffer(buffer))
+}
+
+
+var GreeterService = exports.GreeterService = {
+  SayHello: {
+    path: '/models.Greeter/SayHello',
+    requestStream: false,
+    responseStream: false,
+    requestType: flatbuffers.ByteBuffer,
+    responseType: models_HelloReply,
+    requestSerialize: serialize_models_HelloRequest,
+    requestDeserialize: deserialize_models_HelloRequest,
+    responseSerialize: serialize_models_HelloReply,
+    responseDeserialize: deserialize_models_HelloReply,
+  },
+  SayManyHellos: {
+    path: '/models.Greeter/SayManyHellos',
+    requestStream: false,
+    responseStream: true,
+    requestType: flatbuffers.ByteBuffer,
+    responseType: models_HelloReply,
+    requestSerialize: serialize_models_HelloRequest,
+    requestDeserialize: deserialize_models_HelloRequest,
+    responseSerialize: serialize_models_HelloReply,
+    responseDeserialize: deserialize_models_HelloReply,
+  },
+};
+exports.GreeterClient = grpc.makeGenericClientConstructor(GreeterService);

third_party/flatbuffers/grpc/examples/ts/greeter/src/models.ts

@@ -0,0 +1,6 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+export { HelloReply } from './models/hello-reply.js';
+export { HelloRequest } from './models/hello-request.js';

third_party/flatbuffers/grpc/examples/ts/greeter/src/models/hello-reply.ts

@@ -0,0 +1,60 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+
+
+export class HelloReply {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):HelloReply {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsHelloReply(bb:flatbuffers.ByteBuffer, obj?:HelloReply):HelloReply {
+  return (obj || new HelloReply()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsHelloReply(bb:flatbuffers.ByteBuffer, obj?:HelloReply):HelloReply {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new HelloReply()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+message():string|null
+message(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+message(optionalEncoding?:any):string|Uint8Array|null {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+}
+
+static startHelloReply(builder:flatbuffers.Builder) {
+  builder.startObject(1);
+}
+
+static addMessage(builder:flatbuffers.Builder, messageOffset:flatbuffers.Offset) {
+  builder.addFieldOffset(0, messageOffset, 0);
+}
+
+static endHelloReply(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createHelloReply(builder:flatbuffers.Builder, messageOffset:flatbuffers.Offset):flatbuffers.Offset {
+  HelloReply.startHelloReply(builder);
+  HelloReply.addMessage(builder, messageOffset);
+  return HelloReply.endHelloReply(builder);
+}
+
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):HelloReply {
+  return HelloReply.getRootAsHelloReply(new flatbuffers.ByteBuffer(buffer))
+}
+}

third_party/flatbuffers/grpc/examples/ts/greeter/src/models/hello-request.ts

@@ -0,0 +1,60 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+
+
+export class HelloRequest {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):HelloRequest {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsHelloRequest(bb:flatbuffers.ByteBuffer, obj?:HelloRequest):HelloRequest {
+  return (obj || new HelloRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsHelloRequest(bb:flatbuffers.ByteBuffer, obj?:HelloRequest):HelloRequest {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new HelloRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+name():string|null
+name(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+name(optionalEncoding?:any):string|Uint8Array|null {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+}
+
+static startHelloRequest(builder:flatbuffers.Builder) {
+  builder.startObject(1);
+}
+
+static addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset) {
+  builder.addFieldOffset(0, nameOffset, 0);
+}
+
+static endHelloRequest(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createHelloRequest(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset):flatbuffers.Offset {
+  HelloRequest.startHelloRequest(builder);
+  HelloRequest.addName(builder, nameOffset);
+  return HelloRequest.endHelloRequest(builder);
+}
+
+serialize():Uint8Array {
+  return this.bb!.bytes();
+}
+
+static deserialize(buffer: Uint8Array):HelloRequest {
+  return HelloRequest.getRootAsHelloRequest(new flatbuffers.ByteBuffer(buffer))
+}
+}

third_party/flatbuffers/grpc/examples/ts/greeter/src/server.ts

@@ -0,0 +1,49 @@
+import * as grpc from '@grpc/grpc-js';
+import * as flatbuffers from 'flatbuffers';
+import { HelloReply } from './models/hello-reply';
+import { HelloRequest } from './models/hello-request';
+import { IGreeterServer, GreeterService } from './greeter_grpc';
+
+const greeter: IGreeterServer = {
+    SayHello(call: grpc.ServerUnaryCall<HelloRequest, HelloReply>, callback: grpc.sendUnaryData<HelloReply>): void {
+        console.log(`SayHello ${call.request.name()}`);
+        const builder = new flatbuffers.Builder();
+        const offset = builder.createString(`welcome ${call.request.name()}`);
+        const root = HelloReply.createHelloReply(builder, offset);
+        builder.finish(root);
+        callback(null, HelloReply.getRootAsHelloReply(new flatbuffers.ByteBuffer(builder.asUint8Array())));
+    },
+    async SayManyHellos(call: grpc.ServerWritableStream<HelloRequest, HelloReply>): Promise<void> {
+        const name = call.request.name();
+        console.log(`${call.request.name()} saying hi in different langagues`);
+        ['Hi', 'Hallo', 'Ciao'].forEach(element => {
+            const builder = new flatbuffers.Builder();
+            const offset = builder.createString(`${element} ${name}`);
+            const root = HelloReply.createHelloReply(builder, offset);
+            builder.finish(root);
+            call.write(HelloReply.getRootAsHelloReply(new flatbuffers.ByteBuffer(builder.asUint8Array())))
+        });
+        call.end();
+    }
+}
+
+function serve(): void {
+    const PORT = 3000;
+    const server = new grpc.Server();
+    server.addService(GreeterService, greeter);
+    console.log(`Listening on ${PORT}`);
+    server.bindAsync(
+        `localhost:${PORT}`,
+        grpc.ServerCredentials.createInsecure(),
+        (err: Error | null, port: number) => {
+          if (err) {
+            console.error(`Server error: ${err.message}`);
+          } else {
+            console.log(`Server bound on port: ${port}`);
+            server.start();
+          }
+        }
+      );
+}
+
+serve();

third_party/flatbuffers/grpc/examples/ts/greeter/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "compilerOptions": {
+      "target": "es5",
+      "module": "commonjs",
+      "outDir": "./dist",
+      "allowJs": true,
+      "sourceMap": true,
+      "strict": true,
+      "noImplicitAny": false,
+      "strictNullChecks": false,
+      "esModuleInterop": true,
+      "baseUrl": "./",
+      "typeRoots": ["node_modules/@types"],
+      "skipLibCheck": true, 
+      "forceConsistentCasingInFileNames": true
+    }
+  }