starpc 0.4.9 → 0.5.2

package/echo/echo.pb.ts

@@ -1,8 +1,7 @@
 /* eslint-disable */
 import Long from 'long'
+import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js'
 import * as _m0 from 'protobufjs/minimal'
-import { Observable } from 'rxjs'
-import { map } from 'rxjs/operators'
 
 export const protobufPackage = 'echo'
 
@@ -44,6 +43,40 @@ export const EchoMsg = {
     return message
   },
 
+  // encodeTransform encodes a source of message objects.
+  // Transform<EchoMsg, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [EchoMsg.encode(p).finish()]
+        }
+      } else {
+        yield* [EchoMsg.encode(pkt).finish()]
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, EchoMsg>
+  async *decodeTransform(
+    source:
+      | AsyncIterable<Uint8Array | Uint8Array[]>
+      | Iterable<Uint8Array | Uint8Array[]>
+  ): AsyncIterable<EchoMsg> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [EchoMsg.decode(p)]
+        }
+      } else {
+        yield* [EchoMsg.decode(pkt)]
+      }
+    }
+  },
+
   fromJSON(object: any): EchoMsg {
     return {
       body: isSet(object.body) ? String(object.body) : '',
@@ -68,11 +101,15 @@ export interface Echoer {
   /** Echo returns the given message. */
   Echo(request: EchoMsg): Promise<EchoMsg>
   /** EchoServerStream is an example of a server -> client one-way stream. */
-  EchoServerStream(request: EchoMsg): Observable<EchoMsg>
+  EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>
   /** EchoClientStream is an example of client->server one-way stream. */
-  EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg>
+  EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>
   /** EchoBidiStream is an example of a two-way stream. */
-  EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg>
+  EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>
+  /** RpcStream opens a nested rpc call stream. */
+  RpcStream(
+    request: AsyncIterable<RpcStreamPacket>
+  ): AsyncIterable<RpcStreamPacket>
 }
 
 export class EchoerClientImpl implements Echoer {
@@ -83,6 +120,7 @@ export class EchoerClientImpl implements Echoer {
     this.EchoServerStream = this.EchoServerStream.bind(this)
     this.EchoClientStream = this.EchoClientStream.bind(this)
     this.EchoBidiStream = this.EchoBidiStream.bind(this)
+    this.RpcStream = this.RpcStream.bind(this)
   }
   Echo(request: EchoMsg): Promise<EchoMsg> {
     const data = EchoMsg.encode(request).finish()
@@ -90,20 +128,18 @@ export class EchoerClientImpl implements Echoer {
     return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
   }
 
-  EchoServerStream(request: EchoMsg): Observable<EchoMsg> {
+  EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg> {
     const data = EchoMsg.encode(request).finish()
     const result = this.rpc.serverStreamingRequest(
       'echo.Echoer',
       'EchoServerStream',
       data
     )
-    return result.pipe(map((data) => EchoMsg.decode(new _m0.Reader(data))))
+    return EchoMsg.decodeTransform(result)
   }
 
-  EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg> {
-    const data = request.pipe(
-      map((request) => EchoMsg.encode(request).finish())
-    )
+  EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg> {
+    const data = EchoMsg.encodeTransform(request)
     const promise = this.rpc.clientStreamingRequest(
       'echo.Echoer',
       'EchoClientStream',
@@ -112,16 +148,26 @@ export class EchoerClientImpl implements Echoer {
     return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
   }
 
-  EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg> {
-    const data = request.pipe(
-      map((request) => EchoMsg.encode(request).finish())
-    )
+  EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg> {
+    const data = EchoMsg.encodeTransform(request)
     const result = this.rpc.bidirectionalStreamingRequest(
       'echo.Echoer',
       'EchoBidiStream',
       data
     )
-    return result.pipe(map((data) => EchoMsg.decode(new _m0.Reader(data))))
+    return EchoMsg.decodeTransform(result)
+  }
+
+  RpcStream(
+    request: AsyncIterable<RpcStreamPacket>
+  ): AsyncIterable<RpcStreamPacket> {
+    const data = RpcStreamPacket.encodeTransform(request)
+    const result = this.rpc.bidirectionalStreamingRequest(
+      'echo.Echoer',
+      'RpcStream',
+      data
+    )
+    return RpcStreamPacket.decodeTransform(result)
   }
 }
 
@@ -167,6 +213,15 @@ export const EchoerDefinition = {
       responseStream: true,
       options: {},
     },
+    /** RpcStream opens a nested rpc call stream. */
+    rpcStream: {
+      name: 'RpcStream',
+      requestType: RpcStreamPacket,
+      requestStream: true,
+      responseType: RpcStreamPacket,
+      responseStream: true,
+      options: {},
+    },
   },
 } as const
 
@@ -179,18 +234,18 @@ interface Rpc {
   clientStreamingRequest(
     service: string,
     method: string,
-    data: Observable<Uint8Array>
+    data: AsyncIterable<Uint8Array>
   ): Promise<Uint8Array>
   serverStreamingRequest(
     service: string,
     method: string,
     data: Uint8Array
-  ): Observable<Uint8Array>
+  ): AsyncIterable<Uint8Array>
   bidirectionalStreamingRequest(
     service: string,
     method: string,
-    data: Observable<Uint8Array>
-  ): Observable<Uint8Array>
+    data: AsyncIterable<Uint8Array>
+  ): AsyncIterable<Uint8Array>
 }
 
 type Builtin =

package/echo/echo.proto

@@ -1,6 +1,8 @@
 syntax = "proto3";
 package echo;
 
+import "github.com/aperturerobotics/starpc/rpcstream/rpcstream.proto";
+
 // Echoer service returns the given message.
 service Echoer {
   // Echo returns the given message.
@@ -11,6 +13,8 @@ service Echoer {
   rpc EchoClientStream(stream EchoMsg) returns (EchoMsg);
   // EchoBidiStream is an example of a two-way stream.
   rpc EchoBidiStream(stream EchoMsg) returns (stream EchoMsg);
+  // RpcStream opens a nested rpc call stream.
+  rpc RpcStream(stream .rpcstream.RpcStreamPacket) returns (stream .rpcstream.RpcStreamPacket);
 }
 
 // EchoMsg is the message body for Echo.

package/echo/echo_srpc.pb.go

@@ -7,6 +7,7 @@ package echo
 import (
 	context "context"
 
+	rpcstream "github.com/aperturerobotics/starpc/rpcstream"
 	srpc "github.com/aperturerobotics/starpc/srpc"
 )
 
@@ -17,6 +18,7 @@ type SRPCEchoerClient interface {
 	EchoServerStream(ctx context.Context, in *EchoMsg) (SRPCEchoer_EchoServerStreamClient, error)
 	EchoClientStream(ctx context.Context) (SRPCEchoer_EchoClientStreamClient, error)
 	EchoBidiStream(ctx context.Context) (SRPCEchoer_EchoBidiStreamClient, error)
+	RpcStream(ctx context.Context) (SRPCEchoer_RpcStreamClient, error)
 }
 
 type srpcEchoerClient struct {
@@ -149,11 +151,48 @@ func (x *srpcEchoer_EchoBidiStreamClient) RecvTo(m *EchoMsg) error {
 	return x.MsgRecv(m)
 }
 
+func (c *srpcEchoerClient) RpcStream(ctx context.Context) (SRPCEchoer_RpcStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "RpcStream", nil)
+	if err != nil {
+		return nil, err
+	}
+	strm := &srpcEchoer_RpcStreamClient{stream}
+	return strm, nil
+}
+
+type SRPCEchoer_RpcStreamClient interface {
+	srpc.Stream
+	Send(*rpcstream.RpcStreamPacket) error
+	Recv() (*rpcstream.RpcStreamPacket, error)
+	RecvTo(*rpcstream.RpcStreamPacket) error
+}
+
+type srpcEchoer_RpcStreamClient struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_RpcStreamClient) Send(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcEchoer_RpcStreamClient) Recv() (*rpcstream.RpcStreamPacket, error) {
+	m := new(rpcstream.RpcStreamPacket)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcEchoer_RpcStreamClient) RecvTo(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgRecv(m)
+}
+
 type SRPCEchoerServer interface {
 	Echo(context.Context, *EchoMsg) (*EchoMsg, error)
 	EchoServerStream(*EchoMsg, SRPCEchoer_EchoServerStreamStream) error
 	EchoClientStream(SRPCEchoer_EchoClientStreamStream) error
 	EchoBidiStream(SRPCEchoer_EchoBidiStreamStream) error
+	RpcStream(SRPCEchoer_RpcStreamStream) error
 }
 
 type SRPCEchoerUnimplementedServer struct{}
@@ -174,6 +213,10 @@ func (s *SRPCEchoerUnimplementedServer) EchoBidiStream(SRPCEchoer_EchoBidiStream
 	return srpc.ErrUnimplemented
 }
 
+func (s *SRPCEchoerUnimplementedServer) RpcStream(SRPCEchoer_RpcStreamStream) error {
+	return srpc.ErrUnimplemented
+}
+
 const SRPCEchoerServiceID = "echo.Echoer"
 
 type SRPCEchoerHandler struct {
@@ -188,6 +231,7 @@ func (SRPCEchoerHandler) GetMethodIDs() []string {
 		"EchoServerStream",
 		"EchoClientStream",
 		"EchoBidiStream",
+		"RpcStream",
 	}
 }
 
@@ -208,6 +252,8 @@ func (d *SRPCEchoerHandler) InvokeMethod(
 		return true, d.InvokeMethod_EchoClientStream(d.impl, strm)
 	case "EchoBidiStream":
 		return true, d.InvokeMethod_EchoBidiStream(d.impl, strm)
+	case "RpcStream":
+		return true, d.InvokeMethod_RpcStream(d.impl, strm)
 	default:
 		return false, nil
 	}
@@ -244,6 +290,11 @@ func (SRPCEchoerHandler) InvokeMethod_EchoBidiStream(impl SRPCEchoerServer, strm
 	return impl.EchoBidiStream(clientStrm)
 }
 
+func (SRPCEchoerHandler) InvokeMethod_RpcStream(impl SRPCEchoerServer, strm srpc.Stream) error {
+	clientStrm := &srpcEchoer_RpcStreamStream{strm}
+	return impl.RpcStream(clientStrm)
+}
+
 func SRPCRegisterEchoer(mux srpc.Mux, impl SRPCEchoerServer) error {
 	return mux.Register(&SRPCEchoerHandler{impl: impl})
 }
@@ -331,3 +382,29 @@ func (x *srpcEchoer_EchoBidiStreamStream) Recv() (*EchoMsg, error) {
 func (x *srpcEchoer_EchoBidiStreamStream) RecvTo(m *EchoMsg) error {
 	return x.MsgRecv(m)
 }
+
+type SRPCEchoer_RpcStreamStream interface {
+	srpc.Stream
+	Send(*rpcstream.RpcStreamPacket) error
+	Recv() (*rpcstream.RpcStreamPacket, error)
+}
+
+type srpcEchoer_RpcStreamStream struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_RpcStreamStream) Send(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcEchoer_RpcStreamStream) Recv() (*rpcstream.RpcStreamPacket, error) {
+	m := new(rpcstream.RpcStreamPacket)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcEchoer_RpcStreamStream) RecvTo(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgRecv(m)
+}

package/echo/server.go

@@ -6,11 +6,19 @@ import (
 	"io"
 	"time"
 
+	rpcstream "github.com/aperturerobotics/starpc/rpcstream"
+	srpc "github.com/aperturerobotics/starpc/srpc"
 	"google.golang.org/protobuf/proto"
 )
 
 // EchoServer implements the server side of Echo.
 type EchoServer struct {
+	rpcStreamMux srpc.Mux
+}
+
+// NewEchoServer constructs a EchoServer with a RpcStream mux.
+func NewEchoServer(rpcStreamMux srpc.Mux) *EchoServer {
+	return &EchoServer{rpcStreamMux: rpcStreamMux}
 }
 
 // Echo implements echo.SRPCEchoerServer
@@ -69,5 +77,15 @@ func (s *EchoServer) EchoBidiStream(strm SRPCEchoer_EchoBidiStreamStream) error
 	}
 }
 
+// RpcStream runs a rpc stream
+func (r *EchoServer) RpcStream(stream SRPCEchoer_RpcStreamStream) error {
+	return rpcstream.HandleRpcStream(stream, func(ctx context.Context, componentID string) (srpc.Mux, error) {
+		if r.rpcStreamMux == nil {
+			return nil, errors.New("not implemented")
+		}
+		return r.rpcStreamMux, nil
+	})
+}
+
 // _ is a type assertion
 var _ SRPCEchoerServer = ((*EchoServer)(nil))

package/echo/server.ts

@@ -1,57 +1,63 @@
-import { Observable, from as observableFrom } from 'rxjs'
 import { Echoer, EchoMsg } from './echo.pb.js'
 import { pushable, Pushable } from 'it-pushable'
+import first from 'it-first'
+import { Server } from '../srpc/server.js'
+import { writeToPushable } from '../srpc/pushable.js'
+import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js'
+import { handleRpcStream } from '../rpcstream/rpcstream.js'
 
 // EchoServer implements the Echoer server.
 export class EchoerServer implements Echoer {
+  // proxyServer is the server used for RpcStream requests.
+  private proxyServer?: Server
+
+  constructor(proxyServer?: Server) {
+    this.proxyServer = proxyServer
+  }
+
   public async Echo(request: EchoMsg): Promise<EchoMsg> {
     return request
   }
 
-  public EchoServerStream(request: EchoMsg): Observable<EchoMsg> {
-    // send 5 responses, with a 200ms delay for each
-    return observableFrom(
-      (async function* response(): AsyncIterable<EchoMsg> {
-        for (let i = 0; i < 5; i++) {
-          yield request
-          await new Promise((resolve) => setTimeout(resolve, 200))
-        }
-      })()
-    )
+  public async *EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg> {
+    for (let i = 0; i < 5; i++) {
+      yield request
+      await new Promise((resolve) => setTimeout(resolve, 200))
+    }
   }
 
-  public EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg> {
-    return new Promise<EchoMsg>((resolve, reject) => {
-      request.subscribe({
-        next(msg) {
-          resolve(msg)
-        },
-        error(err: any) {
-          reject(err)
-        },
-        complete() {
-          reject(new Error('none received'))
-        },
-      })
-    })
+  public async EchoClientStream(
+    request: AsyncIterable<EchoMsg>
+  ): Promise<EchoMsg> {
+    // return the first message sent by the client.
+    const message = await first(request)
+    if (!message) {
+      throw new Error('received no messages')
+    }
+    return message
   }
 
-  public EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg> {
+  public EchoBidiStream(
+    request: AsyncIterable<EchoMsg>
+  ): AsyncIterable<EchoMsg> {
     // build result observable
-    const pushResponse: Pushable<EchoMsg> = pushable({ objectMode: true })
-    const response = observableFrom(pushResponse)
-    pushResponse.push({ body: 'hello from server' })
-    request.subscribe({
-      next(msg) {
-        pushResponse.push(msg)
-      },
-      error(err) {
-        pushResponse.throw(err)
-      },
-      complete() {
-        pushResponse.end()
-      },
-    })
-    return response
+    const result: Pushable<EchoMsg> = pushable({ objectMode: true })
+    result.push({ body: 'hello from server' })
+    writeToPushable(request, result)
+    return result
+  }
+
+  public RpcStream(
+    request: AsyncIterable<RpcStreamPacket>
+  ): AsyncIterable<RpcStreamPacket> {
+    return handleRpcStream(
+      request[Symbol.asyncIterator](),
+      async (_componentId: string): Promise<Server> => {
+        if (!this.proxyServer) {
+          throw new Error('rpc stream proxy server not set')
+        }
+        return this.proxyServer
+      }
+    )
   }
 }

package/integration/integration.go

@@ -11,8 +11,7 @@ import (
 
 func main() {
 	mux := srpc.NewMux()
-
-	echoServer := &echo.EchoServer{}
+	echoServer := echo.NewEchoServer(mux)
 	if err := echo.SRPCRegisterEchoer(mux, echoServer); err != nil {
 		logrus.Fatal(err.Error())
 	}

package/integration/integration.ts

@@ -1,5 +1,5 @@
 import { WebSocketConn } from '../srpc/websocket.js'
-import { runClientTest } from '../echo/client-test.js'
+import { runClientTest, runRpcStreamTest } from '../echo/client-test.js'
 import WebSocket from 'isomorphic-ws'
 
 async function runRPC() {
@@ -9,7 +9,11 @@ async function runRPC() {
   const channel = new WebSocketConn(ws)
   const client = channel.buildClient()
 
+  console.log('Running client test via WebSocket..')
   await runClientTest(client)
+
+  console.log('Running RpcStream test via WebSocket..')
+  await runRpcStreamTest(client)
 }
 
 runRPC()

package/integration/integration_srpc.pb.go

@@ -0,0 +1,139 @@
+// Code generated by protoc-gen-srpc. DO NOT EDIT.
+// protoc-gen-srpc version: v0.0.0-20220611014014-aa9dc5523865
+// source: github.com/aperturerobotics/starpc/integration/integration.proto
+
+package main
+
+import (
+	context "context"
+
+	rpcstream "github.com/aperturerobotics/starpc/rpcstream"
+	srpc "github.com/aperturerobotics/starpc/srpc"
+)
+
+type SRPCIntegrationServiceClient interface {
+	SRPCClient() srpc.Client
+
+	RpcStream(ctx context.Context) (SRPCIntegrationService_RpcStreamClient, error)
+}
+
+type srpcIntegrationServiceClient struct {
+	cc srpc.Client
+}
+
+func NewSRPCIntegrationServiceClient(cc srpc.Client) SRPCIntegrationServiceClient {
+	return &srpcIntegrationServiceClient{cc}
+}
+
+func (c *srpcIntegrationServiceClient) SRPCClient() srpc.Client { return c.cc }
+
+func (c *srpcIntegrationServiceClient) RpcStream(ctx context.Context) (SRPCIntegrationService_RpcStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, "main.IntegrationService", "RpcStream", nil)
+	if err != nil {
+		return nil, err
+	}
+	strm := &srpcIntegrationService_RpcStreamClient{stream}
+	return strm, nil
+}
+
+type SRPCIntegrationService_RpcStreamClient interface {
+	srpc.Stream
+	Send(*rpcstream.RpcStreamPacket) error
+	Recv() (*rpcstream.RpcStreamPacket, error)
+	RecvTo(*rpcstream.RpcStreamPacket) error
+}
+
+type srpcIntegrationService_RpcStreamClient struct {
+	srpc.Stream
+}
+
+func (x *srpcIntegrationService_RpcStreamClient) Send(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcIntegrationService_RpcStreamClient) Recv() (*rpcstream.RpcStreamPacket, error) {
+	m := new(rpcstream.RpcStreamPacket)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcIntegrationService_RpcStreamClient) RecvTo(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgRecv(m)
+}
+
+type SRPCIntegrationServiceServer interface {
+	RpcStream(SRPCIntegrationService_RpcStreamStream) error
+}
+
+type SRPCIntegrationServiceUnimplementedServer struct{}
+
+func (s *SRPCIntegrationServiceUnimplementedServer) RpcStream(SRPCIntegrationService_RpcStreamStream) error {
+	return srpc.ErrUnimplemented
+}
+
+const SRPCIntegrationServiceServiceID = "main.IntegrationService"
+
+type SRPCIntegrationServiceHandler struct {
+	impl SRPCIntegrationServiceServer
+}
+
+func (SRPCIntegrationServiceHandler) GetServiceID() string { return SRPCIntegrationServiceServiceID }
+
+func (SRPCIntegrationServiceHandler) GetMethodIDs() []string {
+	return []string{
+		"RpcStream",
+	}
+}
+
+func (d *SRPCIntegrationServiceHandler) InvokeMethod(
+	serviceID, methodID string,
+	strm srpc.Stream,
+) (bool, error) {
+	if serviceID != "" && serviceID != d.GetServiceID() {
+		return false, nil
+	}
+
+	switch methodID {
+	case "RpcStream":
+		return true, d.InvokeMethod_RpcStream(d.impl, strm)
+	default:
+		return false, nil
+	}
+}
+
+func (SRPCIntegrationServiceHandler) InvokeMethod_RpcStream(impl SRPCIntegrationServiceServer, strm srpc.Stream) error {
+	clientStrm := &srpcIntegrationService_RpcStreamStream{strm}
+	return impl.RpcStream(clientStrm)
+}
+
+func SRPCRegisterIntegrationService(mux srpc.Mux, impl SRPCIntegrationServiceServer) error {
+	return mux.Register(&SRPCIntegrationServiceHandler{impl: impl})
+}
+
+type SRPCIntegrationService_RpcStreamStream interface {
+	srpc.Stream
+	Send(*rpcstream.RpcStreamPacket) error
+	Recv() (*rpcstream.RpcStreamPacket, error)
+}
+
+type srpcIntegrationService_RpcStreamStream struct {
+	srpc.Stream
+}
+
+func (x *srpcIntegrationService_RpcStreamStream) Send(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcIntegrationService_RpcStreamStream) Recv() (*rpcstream.RpcStreamPacket, error) {
+	m := new(rpcstream.RpcStreamPacket)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcIntegrationService_RpcStreamStream) RecvTo(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgRecv(m)
+}