starpc 0.4.7 → 0.5.0

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)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.4.7",
+  "version": "0.5.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -42,7 +42,9 @@
     "gen": "make genproto",
     "test": "npm run test:js && npm run test:go",
     "test:go": "make test",
-    "test:js": "npm run build && cd e2e && esbuild e2e.ts --sourcemap --outfile=e2e.js --bundle --platform=node && node ./e2e.js",
+    "build:e2e": "npm run build && cd e2e && esbuild e2e.ts --sourcemap --outfile=e2e.js --bundle --platform=node",
+    "test:js": "npm run build:e2e && cd e2e && node ./e2e.js",
+    "debug:js": "npm run build:e2e && cd e2e && node --inspect --inspect-brk ./e2e.js",
     "test:integration": "make integration",
     "integration": "npm run test:integration",
     "lint": "npm run lint:go && npm run lint:js",
@@ -56,23 +58,24 @@
     "singleQuote": true
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.27.1",
-    "@typescript-eslint/parser": "^5.27.1",
+    "@typescript-eslint/eslint-plugin": "^5.30.0",
+    "@typescript-eslint/parser": "^5.30.0",
     "depcheck": "^1.4.3",
-    "esbuild": "^0.14.46",
+    "esbuild": "^0.14.47",
     "eslint": "^8.18.0",
     "eslint-config-prettier": "^8.5.0",
     "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
-    "ts-proto": "^1.115.4",
+    "ts-proto": "^1.115.5",
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@libp2p/interface-connection": "^2.0.0",
-    "@libp2p/interface-stream-muxer": "^1.0.2",
-    "@libp2p/mplex": "^3.0.0",
+    "@libp2p/interface-connection": "^2.1.1",
+    "@libp2p/interface-stream-muxer": "^2.0.1",
+    "@libp2p/mplex": "^4.0.0",
     "event-iterator": "^2.0.0",
-    "isomorphic-ws": "^4.0.1",
+    "isomorphic-ws": "^5.0.0",
+    "it-first": "^1.0.7",
     "it-length-prefixed": "^7.0.1",
     "it-pipe": "^2.0.3",
     "it-pushable": "^3.0.0",
@@ -81,7 +84,6 @@
     "long": "^5.2.0",
     "patch-package": "^6.4.7",
     "protobufjs": "^6.11.3",
-    "rxjs": "^7.5.5",
     "ws": "^8.8.0"
   }
 }

package/patches/{ts-poet+4.13.0.patch → ts-poet+4.14.0.patch}

@@ -1,5 +1,5 @@
 diff --git a/node_modules/ts-poet/build/Import.js b/node_modules/ts-poet/build/Import.js
-index c43569e..a77a1b1 100644
+index fe1f6d2..280df8f 100644
 --- a/node_modules/ts-poet/build/Import.js
 +++ b/node_modules/ts-poet/build/Import.js
 @@ -293,6 +293,14 @@ function emitImports(imports, ourModulePath, importMappings) {