starpc 0.3.5 → 0.4.1

package/dist/srpc/common-rpc.js

@@ -1,21 +1,7 @@
 import { pushable } from 'it-pushable';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 // CommonRPC is common logic between server and client RPCs.
 export class CommonRPC {
-    // sink is the data sink for incoming messages.
-    sink;
-    // source is the packet source for outgoing Packets.
-    source;
-    // _source is used to write to the source.
-    _source;
-    // rpcDataSource emits incoming client RPC messages to the caller.
-    rpcDataSource;
-    // _rpcDataSource is used to write to the rpc message source.
-    _rpcDataSource;
-    // service is the rpc service
-    service;
-    // method is the rpc method
-    method;
     constructor() {
         this.sink = this._createSink();
         const sourcev = this._createSource();

package/dist/srpc/conn-duplex.js

@@ -4,12 +4,10 @@ import { Conn } from './conn.js';
 //
 // expects Uint8Array objects
 export class DuplexConn extends Conn {
-    // channel is the iterable
-    channel;
     constructor(duplex, server, connParams) {
         super(server, connParams);
         this.channel = duplex;
-        pipe(this, this.channel, this);
+        pipe(this.channel, this, this.channel);
     }
     // getChannelDuplex returns the Duplex channel.
     getChannelDuplex() {

package/dist/srpc/conn.d.ts

@@ -7,7 +7,7 @@ export interface ConnParams {
     muxerFactory?: StreamMuxerFactory;
 }
 export interface StreamHandler {
-    handleStream(strm: Duplex<Uint8Array>): Promise<void>;
+    handleStream(strm: Duplex<Uint8Array>): void;
 }
 export declare class Conn implements Duplex<Uint8Array> {
     private muxer;

package/dist/srpc/conn.js

@@ -5,10 +5,6 @@ import { Client } from './client.js';
 // Implements the server by handling incoming streams.
 // If the server is unset, rejects any incoming streams.
 export class Conn {
-    // muxer is the mplex stream muxer.
-    muxer;
-    // server is the server side, if set.
-    server;
     constructor(server, connParams) {
         if (server) {
             this.server = server;

package/dist/srpc/handler.js

@@ -4,10 +4,6 @@ import { from as observableFrom } from 'rxjs';
 import { buildDecodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
 // StaticHandler is a handler with a definition and implementation.
 export class StaticHandler {
-    // service is the service id
-    service;
-    // methods is the map of method to invoke fn
-    methods;
     constructor(serviceID, methods) {
         this.service = serviceID;
         this.methods = methods;
@@ -38,23 +34,27 @@ export function createInvokeFn(methodInfo, methodProto) {
             objectMode: true,
         });
         // pipe responseSink to dataSink.
-        const responsePipe = pipe(responseSink, buildEncodeMessageTransform(methodInfo.responseType), dataSink);
+        pipe(responseSink, buildEncodeMessageTransform(methodInfo.responseType), dataSink);
+        // requestSource is a Source of decoded request messages.
+        const requestSource = pipe(dataSource, requestDecode);
         // build the request argument.
         let requestArg;
         if (methodInfo.requestStream) {
-            // requestSource is a Source of decoded request messages.
-            const requestSource = pipe(dataSource, requestDecode);
             // convert the request data source into an Observable<T>
             requestArg = observableFrom(requestSource);
         }
         else {
             // receive a single message for the argument.
-            const requestRx = requestDecode(dataSource);
-            for await (const msg of requestRx) {
-                requestArg = msg;
-                break;
+            for await (const msg of requestSource) {
+                if (msg) {
+                    requestArg = msg;
+                    break;
+                }
             }
         }
+        if (!requestArg) {
+            throw new Error('request object was empty');
+        }
         // Call the implementation.
         try {
             const responseObj = methodProto(requestArg);
@@ -77,9 +77,7 @@ export function createInvokeFn(methodInfo, methodProto) {
                         },
                         complete: () => {
                             responseSink.end();
-                            responsePipe.finally(() => {
-                                resolve();
-                            });
+                            resolve();
                         },
                     });
                 });

package/dist/srpc/index.d.ts

@@ -1,4 +1,4 @@
-export type { OpenStreamFunc } from './stream.js';
+export type { PacketHandler, Stream, OpenStreamFunc } from './stream.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { Conn, ConnParams } from './conn.js';
@@ -6,3 +6,4 @@ export { Handler, InvokeFn, createHandler, createInvokeFn } from './handler.js';
 export { Mux, createMux } from './mux.js';
 export { BroadcastChannelIterable, newBroadcastChannelIterable, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
+export { ObservableSource } from './observable-source.js';

package/dist/srpc/index.js

@@ -5,3 +5,4 @@ export { createHandler, createInvokeFn } from './handler.js';
 export { createMux } from './mux.js';
 export { BroadcastChannelIterable, newBroadcastChannelIterable, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
+export { ObservableSource } from './observable-source.js';

package/dist/srpc/message-port.js

@@ -2,14 +2,6 @@ import { EventIterator } from 'event-iterator';
 import { DuplexConn } from './conn-duplex.js';
 // MessagePortIterable is a AsyncIterable wrapper for MessagePort.
 export class MessagePortIterable {
-    // port is the message port
-    port;
-    // sink is the sink for incoming messages.
-    sink;
-    // source is the source for outgoing messages.
-    source;
-    // _source is the EventIterator for source.
-    _source;
     constructor(port) {
         this.port = port;
         this.sink = this._createSink();
@@ -51,8 +43,6 @@ export function newMessagePortIterable(port) {
 //
 // expects Uint8Array objects over the MessagePort.
 export class MessagePortConn extends DuplexConn {
-    // messagePort is the message port iterable.
-    messagePort;
     constructor(port, server, connParams) {
         const messagePort = new MessagePortIterable(port);
         super(messagePort, server, connParams);

package/dist/srpc/mux.js

@@ -5,8 +5,10 @@ export function createMux() {
 // StaticMux contains a in-memory mapping between service ID and handlers.
 // implements Mux
 export class StaticMux {
-    // services contains a mapping from service id to handlers.
-    services = {};
+    constructor() {
+        // services contains a mapping from service id to handlers.
+        this.services = {};
+    }
     register(handler) {
         const serviceID = handler?.getServiceID();
         if (!serviceID) {

package/dist/srpc/observable-source.d.ts

@@ -0,0 +1,9 @@
+import { Source } from 'it-stream-types';
+import { Observable } from 'rxjs';
+export declare class ObservableSource<T> {
+    readonly source: Source<T>;
+    private readonly _source;
+    private readonly subscription;
+    constructor(observable: Observable<T>);
+    close(err?: Error): void;
+}

package/dist/srpc/observable-source.js

@@ -0,0 +1,25 @@
+import { pushable } from 'it-pushable';
+// ObservableSource wraps an Observable into a Source.
+export class ObservableSource {
+    constructor(observable) {
+        const source = pushable({ objectMode: true });
+        this.source = source;
+        this._source = source;
+        this.subscription = observable.subscribe({
+            next: (value) => {
+                this._source.push(value);
+            },
+            error: (err) => {
+                this._source.end(err);
+            },
+            complete: () => {
+                this._source.end();
+            },
+        });
+    }
+    // close closes the subscription.
+    close(err) {
+        this._source.end(err);
+        this.subscription.unsubscribe();
+    }
+}

package/dist/srpc/packet.d.ts

@@ -1,5 +1,5 @@
 import type { Transform } from 'it-stream-types';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 export declare const decodePacketSource: (source: import("it-stream-types").Source<Uint8Array | Uint8Array[]>) => AsyncIterable<Packet>;
 export declare const encodePacketSource: (source: import("it-stream-types").Source<Packet | Packet[]>) => AsyncIterable<Uint8Array>;
 export declare function prependLengthPrefixTransform(): Transform<Uint8Array>;

package/dist/srpc/packet.js

@@ -1,5 +1,5 @@
 import { encode as lengthPrefixEncode, decode as lengthPrefixDecode, } from 'it-length-prefixed';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 import { buildDecodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
 // decodePacketSource decodes packets from a binary data stream.
 export const decodePacketSource = buildDecodeMessageTransform(Packet);

package/dist/srpc/server-rpc.d.ts

@@ -1,4 +1,4 @@
-import type { CallData, CallStart } from './rpcproto.js';
+import type { CallData, CallStart } from './rpcproto.pb.js';
 import { CommonRPC } from './common-rpc.js';
 import { Mux } from './mux.js';
 export declare class ServerRPC extends CommonRPC {

package/dist/srpc/server-rpc.js

@@ -1,8 +1,6 @@
 import { CommonRPC } from './common-rpc.js';
 // ServerRPC is an ongoing RPC from the server side.
 export class ServerRPC extends CommonRPC {
-    // mux is used to handle incoming rpcs.
-    mux;
     constructor(mux) {
         super();
         this.mux = mux;

package/dist/srpc/server.d.ts

@@ -2,13 +2,13 @@ import { Stream } from '@libp2p/interface-connection';
 import { Duplex } from 'it-stream-types';
 import { Mux } from './mux.js';
 import { ServerRPC } from './server-rpc.js';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 import { StreamHandler } from './conn.js';
 export declare class Server implements StreamHandler {
     private mux;
     constructor(mux: Mux);
     startRpc(): ServerRPC;
-    handleStream(stream: Stream): Promise<void>;
-    handleDuplex(stream: Duplex<Uint8Array>): Promise<void>;
-    handlePacketStream(stream: Duplex<Packet>): Promise<void>;
+    handleStream(stream: Stream): ServerRPC;
+    handleDuplex(stream: Duplex<Uint8Array>): ServerRPC;
+    handlePacketStream(stream: Duplex<Packet>): ServerRPC;
 }

package/dist/srpc/server.js

@@ -3,8 +3,6 @@ import { ServerRPC } from './server-rpc.js';
 import { parseLengthPrefixTransform, prependLengthPrefixTransform, decodePacketSource, encodePacketSource, } from './packet.js';
 // Server implements the SRPC server in TypeScript with a Mux.
 export class Server {
-    // mux is the mux used to handle requests.
-    mux;
     constructor(mux) {
         this.mux = mux;
     }
@@ -14,18 +12,19 @@ export class Server {
         return new ServerRPC(this.mux);
     }
     // handleStream handles an incoming Uint8Array message duplex.
-    // closes the stream when the rpc completes.
     handleStream(stream) {
         return this.handleDuplex(stream);
     }
     // handleDuplex handles an incoming message duplex.
-    async handleDuplex(stream) {
+    handleDuplex(stream) {
         const rpc = this.startRpc();
-        await pipe(stream, parseLengthPrefixTransform(), decodePacketSource, rpc, encodePacketSource, prependLengthPrefixTransform(), stream);
+        pipe(stream, parseLengthPrefixTransform(), decodePacketSource, rpc, encodePacketSource, prependLengthPrefixTransform(), stream);
+        return rpc;
     }
     // handlePacketStream handles an incoming Packet duplex.
-    async handlePacketStream(stream) {
+    handlePacketStream(stream) {
         const rpc = this.startRpc();
-        await pipe(stream, rpc, stream);
+        pipe(stream, rpc, stream);
+        return rpc;
     }
 }

package/dist/srpc/stream.d.ts

@@ -1,4 +1,4 @@
-import type { Packet } from './rpcproto';
+import type { Packet } from './rpcproto.pb.js';
 import type { Duplex } from 'it-stream-types';
 export declare type PacketHandler = (packet: Packet) => Promise<void>;
 export declare type Stream = Duplex<Uint8Array>;

package/dist/srpc/websocket.js

@@ -4,15 +4,13 @@ import { Mplex } from '@libp2p/mplex';
 import { Conn } from './conn.js';
 // WebSocketConn implements a connection with a WebSocket and optional Server.
 export class WebSocketConn extends Conn {
-    // socket is the web socket
-    socket;
     constructor(socket, server) {
         super(server, {
             muxerFactory: new Mplex(),
         });
         this.socket = socket;
         const socketDuplex = duplex(socket);
-        pipe(this.source, socketDuplex, this.sink);
+        pipe(socketDuplex, this, socketDuplex);
     }
     // getSocket returns the websocket.
     getSocket() {

package/e2e/e2e_test.go

@@ -3,10 +3,13 @@ package e2e
 import (
 	"context"
 	"io"
+	"net"
 	"testing"
 
 	"github.com/aperturerobotics/starpc/echo"
 	"github.com/aperturerobotics/starpc/srpc"
+	"github.com/libp2p/go-libp2p/p2p/muxer/mplex"
+	mp "github.com/libp2p/go-mplex"
 	"github.com/pkg/errors"
 )
 
@@ -20,9 +23,24 @@ func RunE2E(t *testing.T, cb func(client echo.SRPCEchoerClient) error) {
 	}
 	server := srpc.NewServer(mux)
 
+	// note: also possible to do without mplex:
+	// openStream := srpc.NewServerPipe(server)
+	// client := srpc.NewClient(openStream)
+
 	// construct the client
-	openStream := srpc.NewServerPipe(server)
-	client := srpc.NewClient(openStream)
+	clientPipe, serverPipe := net.Pipe()
+
+	ctx := context.Background()
+	go func() {
+		serverMp, _ := mp.NewMultiplex(serverPipe, false, nil)
+		_ = server.AcceptMuxedConn(ctx, mplex.NewMuxedConn(serverMp))
+	}()
+
+	clientMp, err := mp.NewMultiplex(clientPipe, true, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	client := srpc.NewClientWithMuxedConn(mplex.NewMuxedConn(clientMp))
 
 	// construct the client rpc interface
 	clientEcho := echo.NewSRPCEchoerClient(client)

package/echo/client-test.ts

@@ -1,5 +1,5 @@
 import { Client } from '../srpc/index.js'
-import { EchoerClientImpl, EchoMsg } from './echo.js'
+import { EchoerClientImpl, EchoMsg } from './echo.pb.js'
 import { Observable } from 'rxjs'
 
 export async function runClientTest(client: Client) {

package/echo/index.ts

@@ -1,3 +1,3 @@
-export * from './echo.js'
+export * from './echo.pb.js'
 export * from './server.js'
 export { runClientTest } from './client-test.js'

package/echo/server.ts

@@ -1,5 +1,5 @@
 import { Observable, from as observableFrom } from 'rxjs'
-import { Echoer, EchoMsg } from './echo'
+import { Echoer, EchoMsg } from './echo.pb.js'
 import { pushable, Pushable } from 'it-pushable'
 
 // EchoServer implements the Echoer server.

package/go.mod

@@ -9,8 +9,9 @@ require (
 )
 
 require (
-	github.com/libp2p/go-libp2p v0.20.1
+	github.com/libp2p/go-libp2p v0.20.1-0.20220622205512-3cf611ad8c9c
 	github.com/libp2p/go-libp2p-core v0.16.1
+	github.com/libp2p/go-mplex v0.7.0
 	github.com/sirupsen/logrus v1.8.2-0.20220112234510-85981c045988
 )
 
@@ -25,7 +26,6 @@ require (
 	github.com/klauspost/compress v1.15.1 // indirect
 	github.com/klauspost/cpuid/v2 v2.0.12 // indirect
 	github.com/libp2p/go-buffer-pool v0.0.2 // indirect
-	github.com/libp2p/go-mplex v0.7.0 // indirect
 	github.com/libp2p/go-openssl v0.0.7 // indirect
 	github.com/mattn/go-isatty v0.0.14 // indirect
 	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 // indirect

package/go.sum

@@ -65,8 +65,8 @@ github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/libp2p/go-buffer-pool v0.0.2 h1:QNK2iAFa8gjAe1SPz6mHSMuCcjs+X1wlHzeOSqcmlfs=
 github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM=
-github.com/libp2p/go-libp2p v0.20.1 h1:tCgC8yXtleyOg/mp+ZoCcA+aryAhueCfFmAVXURT/PM=
-github.com/libp2p/go-libp2p v0.20.1/go.mod h1:XgJHsOhEBVBXp/2Sj9bm/yEyD94uunAaP6oaegdcKks=
+github.com/libp2p/go-libp2p v0.20.1-0.20220622205512-3cf611ad8c9c h1:BTR12zXVGQtdk9bT5GLOmdzJrhyFO6YUH3/e8lnkjQ0=
+github.com/libp2p/go-libp2p v0.20.1-0.20220622205512-3cf611ad8c9c/go.mod h1:tqyre7jPbLfhzjQfpiFX6x7wj/sqt1074riPM0Xn/qI=
 github.com/libp2p/go-libp2p-core v0.16.1 h1:bWoiEBqVkpJ13hbv/f69tHODp86t6mvc4fBN4DkK73M=
 github.com/libp2p/go-libp2p-core v0.16.1/go.mod h1:O3i/7y+LqUb0N+qhzXjBjjpchgptWAVMG1Voegk7b4c=
 github.com/libp2p/go-libp2p-testing v0.9.2 h1:dCpODRtRaDZKF8HXT9qqqgON+OMEB423Knrgeod8j84=

package/integration/integration.ts

@@ -1,5 +1,5 @@
-import { WebSocketConn } from '../srpc/websocket'
-import { runClientTest } from '../echo'
+import { WebSocketConn } from '../srpc/websocket.js'
+import { runClientTest } from '../echo/client-test.js'
 import WebSocket from 'isomorphic-ws'
 
 async function runRPC() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.3.5",
+  "version": "0.4.1",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -22,6 +22,7 @@
     "Makefile",
     "dist/echo",
     "dist/srpc",
+    "dist/rpcstream",
     "e2e",
     "echo",
     "go.mod",
@@ -39,7 +40,7 @@
     "deps": "depcheck",
     "codegen": "npm run gen",
     "ci": "npm run build && npm run lint:js && npm run lint:go",
-    "format": "prettier --write './{srpc,echo,e2e,integration}/**/(*.ts|*.tsx|*.html|*.css)'",
+    "format": "prettier --write './{srpc,echo,e2e,integration,rpcstream}/**/(*.ts|*.tsx|*.html|*.css)'",
     "gen": "make genproto",
     "test": "npm run test:js && npm run test:go",
     "test:go": "make test",
@@ -48,7 +49,7 @@
     "integration": "npm run test:integration",
     "lint": "npm run lint:go && npm run lint:js",
     "lint:go": "make lint",
-    "lint:js": "eslint -c .eslintrc.js --ext .ts ./{srpc,echo}/**/*.ts",
+    "lint:js": "eslint -c .eslintrc.js --ext .ts ./{srpc,echo,rpcstream}/**/*.ts",
     "prepare": "patch-package",
     "precommit": "npm run format"
   },

package/srpc/broadcast-channel.ts

@@ -46,8 +46,8 @@ export class BroadcastChannelIterable<T> implements Duplex<T> {
           queue.push(ev.data)
         }
       }
-      this.readChannel.addEventListener('message', messageListener)
 
+      this.readChannel.addEventListener('message', messageListener)
       return () => {
         this.readChannel.removeEventListener('message', messageListener)
       }

package/srpc/client-rpc.go

@@ -46,9 +46,8 @@ func NewClientRPC(ctx context.Context, service, method string) *ClientRPC {
 }
 
 // Start sets the writer and writes the MsgSend message.
-// firstMsg can be nil, but is usually set if this is a non-streaming rpc.
 // must only be called once!
-func (r *ClientRPC) Start(writer Writer, firstMsg []byte) error {
+func (r *ClientRPC) Start(writer Writer, writeFirstMsg bool, firstMsg []byte) error {
 	select {
 	case <-r.ctx.Done():
 		r.Close()
@@ -56,7 +55,13 @@ func (r *ClientRPC) Start(writer Writer, firstMsg []byte) error {
 	default:
 	}
 	r.writer = writer
-	pkt := NewCallStartPacket(r.service, r.method, firstMsg)
+	var firstMsgEmpty bool
+	if writeFirstMsg {
+		firstMsgEmpty = len(firstMsg) == 0
+	} else {
+		firstMsg = nil
+	}
+	pkt := NewCallStartPacket(r.service, r.method, firstMsg, firstMsgEmpty)
 	if err := writer.WritePacket(pkt); err != nil {
 		r.Close()
 		return err

package/srpc/client-rpc.ts

@@ -1,4 +1,4 @@
-import type { CallStart } from './rpcproto.js'
+import type { CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
 
 // ClientRPC is an ongoing RPC from the client side.

package/srpc/client.go

@@ -19,7 +19,7 @@ type Client interface {
 
 // OpenStreamFunc opens a stream with a remote.
 // msgHandler must not be called concurrently.
-type OpenStreamFunc = func(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error)
+type OpenStreamFunc = func(ctx context.Context, msgHandler PacketHandler) (Writer, error)
 
 // client implements Client with a transport.
 type client struct {
@@ -48,7 +48,7 @@ func (c *client) Invoke(rctx context.Context, service, method string, in, out Me
 	if err != nil {
 		return err
 	}
-	if err := clientRPC.Start(writer, firstMsg); err != nil {
+	if err := clientRPC.Start(writer, true, firstMsg); err != nil {
 		return err
 	}
 	msgs, err := clientRPC.ReadAll()
@@ -85,11 +85,11 @@ func (c *client) NewStream(ctx context.Context, service, method string, firstMsg
 	if err != nil {
 		return nil, err
 	}
-	if err := clientRPC.Start(writer, firstMsgData); err != nil {
+	if err := clientRPC.Start(writer, firstMsg != nil, firstMsgData); err != nil {
 		return nil, err
 	}
 
-	return NewRPCStream(ctx, clientRPC.writer, clientRPC.dataCh), nil
+	return NewMsgStream(ctx, clientRPC.writer, clientRPC.dataCh), nil
 }
 
 // _ is a type assertion

package/srpc/client.ts

@@ -29,36 +29,38 @@ function writeClientStream(call: ClientRPC, data: Observable<Uint8Array>) {
 
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client implements TsProtoRpc {
-  // openConnFn is a promise which contains the OpenStreamFunc.
-  private openConnFn: Promise<OpenStreamFunc>
-  // _openConnFn resolves openConnFn.
-  private _openConnFn?: (conn?: OpenStreamFunc, err?: Error) => void
+  // openStreamFn is a promise which contains the OpenStreamFunc.
+  private openStreamFn: Promise<OpenStreamFunc>
+  // _openStreamFn resolves openStreamFn.
+  private _openStreamFn?: (conn?: OpenStreamFunc, err?: Error) => void
 
-  constructor(openConnFn?: OpenStreamFunc) {
-    this.openConnFn = this.setOpenConnFn(openConnFn)
+  constructor(openStreamFn?: OpenStreamFunc) {
+    this.openStreamFn = this.setOpenStreamFn(openStreamFn)
   }
 
-  // setOpenConnFn updates the openConnFn for the Client.
-  public setOpenConnFn(openConnFn?: OpenStreamFunc): Promise<OpenStreamFunc> {
-    if (this._openConnFn) {
-      if (openConnFn) {
-        this._openConnFn(openConnFn)
-        this._openConnFn = undefined
+  // setOpenStreamFn updates the openStreamFn for the Client.
+  public setOpenStreamFn(
+    openStreamFn?: OpenStreamFunc
+  ): Promise<OpenStreamFunc> {
+    if (this._openStreamFn) {
+      if (openStreamFn) {
+        this._openStreamFn(openStreamFn)
+        this._openStreamFn = undefined
       }
     } else {
-      if (openConnFn) {
-        this.openConnFn = Promise.resolve(openConnFn)
+      if (openStreamFn) {
+        this.openStreamFn = Promise.resolve(openStreamFn)
       } else {
-        this.initOpenConnFn()
+        this.initOpenStreamFn()
       }
     }
-    return this.openConnFn
+    return this.openStreamFn
   }
 
-  // initOpenConnFn creates the empty Promise for openConnFn.
-  private initOpenConnFn(): Promise<OpenStreamFunc> {
+  // initOpenStreamFn creates the empty Promise for openStreamFn.
+  private initOpenStreamFn(): Promise<OpenStreamFunc> {
     const openPromise = new Promise<OpenStreamFunc>((resolve, reject) => {
-      this._openConnFn = (conn?: OpenStreamFunc, err?: Error) => {
+      this._openStreamFn = (conn?: OpenStreamFunc, err?: Error) => {
         if (err) {
           reject(err)
         } else if (conn) {
@@ -66,8 +68,8 @@ export class Client implements TsProtoRpc {
         }
       }
     })
-    this.openConnFn = openPromise
-    return this.openConnFn
+    this.openStreamFn = openPromise
+    return this.openStreamFn
   }
 
   // request starts a non-streaming request.
@@ -109,7 +111,7 @@ export class Client implements TsProtoRpc {
     method: string,
     data: Uint8Array
   ): Observable<Uint8Array> {
-    const pushServerData: Pushable<Uint8Array> = pushable()
+    const pushServerData: Pushable<Uint8Array> = pushable({ objectMode: true })
     const serverData = observableFrom(pushServerData)
     this.startRpc(service, method, data)
       .then(async (call) => {
@@ -132,7 +134,7 @@ export class Client implements TsProtoRpc {
     method: string,
     data: Observable<Uint8Array>
   ): Observable<Uint8Array> {
-    const pushServerData: Pushable<Uint8Array> = pushable()
+    const pushServerData: Pushable<Uint8Array> = pushable({ objectMode: true })
     const serverData = observableFrom(pushServerData)
     this.startRpc(service, method, null)
       .then(async (call) => {
@@ -168,8 +170,8 @@ export class Client implements TsProtoRpc {
     rpcMethod: string,
     data: Uint8Array | null
   ): Promise<ClientRPC> {
-    const openConnFn = await this.openConnFn
-    const conn = await openConnFn()
+    const openStreamFn = await this.openStreamFn
+    const conn = await openStreamFn()
     const call = new ClientRPC(rpcService, rpcMethod)
     pipe(
       conn,