starpc 0.4.7 → 0.5.0

package/Makefile

@@ -109,6 +109,7 @@ gents: $(PROTOWRAP) node_modules
 		--ts_proto_opt=forceLong=long \
 		--ts_proto_opt=oneof=unions \
 		--ts_proto_opt=outputServices=default,outputServices=generic-definitions \
+		--ts_proto_opt=useAsyncIterable=true \
 		--proto_path $$(pwd)/vendor \
 		--print_structure \
 		--only_specified_files \

package/README.md

@@ -19,19 +19,17 @@ Can use any Stream multiplexer: defaults to [libp2p-mplex] over a WebSocket.
 
 # Usage
 
-Starting with the [protobuf-project] repository on the "starpc" branch.
+Start with the [protobuf-project] template repository on the "starpc" branch.
+
+[protobuf-project]: https://github.com/aperturerobotics/protobuf-project/tree/starpc
 
 Use "git add" to add your new .proto files, then `yarn gen` to generate the
-TypeScript and Go code for them.
+TypeScript and Go code.
 
 # Examples
 
-See the [protobuf-project] template on the "starpc" branch.
-
 The demo/boilerplate project implements the Echo example below.
 
-[protobuf-project]: https://github.com/aperturerobotics/protobuf-project/tree/starpc
-
 This repository uses protowrap, see the [Makefile](./Makefile).
 
 ## Protobuf
@@ -118,6 +116,7 @@ This example demonstrates both the server and client:
 import { pipe } from 'it-pipe'
 import { createHandler, createMux, Server, Client, Conn } from 'srpc'
 import { EchoerDefinition, EchoerServer, runClientTest } from 'srpc/echo'
+import { pushable } from 'it-pushable'
 
 const mux = createMux()
 const echoer = new EchoerServer()
@@ -129,20 +128,31 @@ const serverConn = new Conn(server)
 pipe(clientConn, serverConn, clientConn)
 const client = new Client(clientConn.buildOpenStreamFunc())
 
+// call the unary rpc
 console.log('Calling Echo: unary call...')
 let result = await demoServiceClient.Echo({
   body: 'Hello world!',
 })
 console.log('success: output', result.body)
 
-const clientRequestStream = new Observable<EchoMsg>(subscriber => {
-  subscriber.next({body: 'Hello world from streaming request.'})
-  subscriber.complete()
-})
+// create a client -> server stream
+const clientRequestStream = pushable<EchoMsg>({objectMode: true})
+clientRequestStream.push({body: 'Hello world from streaming request.'})
+clientRequestStream.end()
 
+// call the client -> server streaming rpc
 console.log('Calling EchoClientStream: client -> server...')
 result = await demoServiceClient.EchoClientStream(clientRequestStream)
 console.log('success: output', result.body)
+
+// call the server -> client streaming rpc
+console.log('Calling EchoServerStream: server -> client...')
+const serverStream = demoServiceClient.EchoServerStream({
+  body: 'Hello world from server to client streaming request.',
+})
+for await (const msg of serverStream) {
+  console.log('server: output', msg.body)
+}
 ```
 
 ## WebSocket

package/dist/echo/client-test.d.ts

@@ -1,2 +1,3 @@
 import { Client } from '../srpc/index.js';
 export declare function runClientTest(client: Client): Promise<void>;
+export declare function runRpcStreamTest(client: Client): Promise<void>;

package/dist/echo/client-test.js

@@ -1,5 +1,7 @@
+import { Client } from '../srpc/index.js';
 import { EchoerClientImpl } from './echo.pb.js';
-import { Observable } from 'rxjs';
+import { pushable } from 'it-pushable';
+import { buildRpcStreamOpenStream } from '../rpcstream/rpcstream.js';
 export async function runClientTest(client) {
     const demoServiceClient = new EchoerClientImpl(client);
     console.log('Calling Echo: unary call...');
@@ -8,10 +10,9 @@ export async function runClientTest(client) {
     });
     console.log('success: output', result.body);
     // observable for client requests
-    const clientRequestStream = new Observable((subscriber) => {
-        subscriber.next({ body: 'Hello world from streaming request.' });
-        subscriber.complete();
-    });
+    const clientRequestStream = pushable({ objectMode: true });
+    clientRequestStream.push({ body: 'Hello world from streaming request.' });
+    clientRequestStream.end();
     console.log('Calling EchoClientStream: client -> server...');
     result = await demoServiceClient.EchoClientStream(clientRequestStream);
     console.log('success: output', result.body);
@@ -19,17 +20,18 @@ export async function runClientTest(client) {
     const serverStream = demoServiceClient.EchoServerStream({
         body: 'Hello world from server to client streaming request.',
     });
-    await new Promise((resolve, reject) => {
-        serverStream.subscribe({
-            next(result) {
-                console.log('server: output', result.body);
-            },
-            complete() {
-                resolve();
-            },
-            error(err) {
-                reject(err);
-            },
-        });
-    });
+    for await (const msg of serverStream) {
+        console.log('server: output', msg.body);
+    }
+}
+// runRpcStreamTest tests a RPCStream.
+export async function runRpcStreamTest(client) {
+    console.log('Calling RpcStream to open a RPC stream client...');
+    const service = new EchoerClientImpl(client);
+    const openStreamFn = buildRpcStreamOpenStream('test', service.RpcStream.bind(service));
+    const proxiedClient = new Client(openStreamFn);
+    const proxiedService = new EchoerClientImpl(proxiedClient);
+    console.log('Calling Echo via RPC stream...');
+    const resp = await proxiedService.Echo({ body: 'hello world via proxy' });
+    console.log('rpc stream test: succeeded: response: ' + resp.body);
 }

package/dist/echo/echo.pb.d.ts

@@ -1,6 +1,7 @@
 import Long from 'long';
+import { EchoMsg as EchoMsg1 } from './echo.pb.js';
+import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js';
 import * as _m0 from 'protobufjs/minimal';
-import { Observable } from 'rxjs';
 export declare const protobufPackage = "echo";
 /** EchoMsg is the message body for Echo. */
 export interface EchoMsg {
@@ -9,6 +10,8 @@ export interface EchoMsg {
 export declare const EchoMsg: {
     encode(message: EchoMsg, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg;
+    encodeTransform(source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>): AsyncIterable<Uint8Array>;
+    decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<EchoMsg>;
     fromJSON(object: any): EchoMsg;
     toJSON(message: EchoMsg): unknown;
     fromPartial<I extends {
@@ -20,21 +23,24 @@ export declare const EchoMsg: {
 /** Echoer service returns the given message. */
 export interface Echoer {
     /** Echo returns the given message. */
-    Echo(request: EchoMsg): Promise<EchoMsg>;
+    Echo(request: EchoMsg1): Promise<EchoMsg1>;
     /** EchoServerStream is an example of a server -> client one-way stream. */
-    EchoServerStream(request: EchoMsg): Observable<EchoMsg>;
+    EchoServerStream(request: EchoMsg1): AsyncIterable<EchoMsg1>;
     /** EchoClientStream is an example of client->server one-way stream. */
-    EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg>;
+    EchoClientStream(request: AsyncIterable<EchoMsg1>): Promise<EchoMsg1>;
     /** EchoBidiStream is an example of a two-way stream. */
-    EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg>;
+    EchoBidiStream(request: AsyncIterable<EchoMsg1>): AsyncIterable<EchoMsg1>;
+    /** RpcStream opens a nested rpc call stream. */
+    RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket>;
 }
 export declare class EchoerClientImpl implements Echoer {
     private readonly rpc;
     constructor(rpc: Rpc);
-    Echo(request: EchoMsg): Promise<EchoMsg>;
-    EchoServerStream(request: EchoMsg): Observable<EchoMsg>;
-    EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg>;
-    EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg>;
+    Echo(request: EchoMsg1): Promise<EchoMsg1>;
+    EchoServerStream(request: EchoMsg1): AsyncIterable<EchoMsg1>;
+    EchoClientStream(request: AsyncIterable<EchoMsg1>): Promise<EchoMsg1>;
+    EchoBidiStream(request: AsyncIterable<EchoMsg1>): AsyncIterable<EchoMsg1>;
+    RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket>;
 }
 /** Echoer service returns the given message. */
 export declare type EchoerDefinition = typeof EchoerDefinition;
@@ -48,6 +54,8 @@ export declare const EchoerDefinition: {
             readonly requestType: {
                 encode(message: EchoMsg, writer?: _m0.Writer): _m0.Writer;
                 decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg;
+                encodeTransform(source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<EchoMsg>;
                 fromJSON(object: any): EchoMsg;
                 toJSON(message: EchoMsg): unknown;
                 fromPartial<I extends {
@@ -60,6 +68,8 @@ export declare const EchoerDefinition: {
             readonly responseType: {
                 encode(message: EchoMsg, writer?: _m0.Writer): _m0.Writer;
                 decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg;
+                encodeTransform(source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<EchoMsg>;
                 fromJSON(object: any): EchoMsg;
                 toJSON(message: EchoMsg): unknown;
                 fromPartial<I extends {
@@ -77,6 +87,8 @@ export declare const EchoerDefinition: {
             readonly requestType: {
                 encode(message: EchoMsg, writer?: _m0.Writer): _m0.Writer;
                 decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg;
+                encodeTransform(source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<EchoMsg>;
                 fromJSON(object: any): EchoMsg;
                 toJSON(message: EchoMsg): unknown;
                 fromPartial<I extends {
@@ -89,6 +101,8 @@ export declare const EchoerDefinition: {
             readonly responseType: {
                 encode(message: EchoMsg, writer?: _m0.Writer): _m0.Writer;
                 decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg;
+                encodeTransform(source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<EchoMsg>;
                 fromJSON(object: any): EchoMsg;
                 toJSON(message: EchoMsg): unknown;
                 fromPartial<I extends {
@@ -106,6 +120,8 @@ export declare const EchoerDefinition: {
             readonly requestType: {
                 encode(message: EchoMsg, writer?: _m0.Writer): _m0.Writer;
                 decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg;
+                encodeTransform(source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<EchoMsg>;
                 fromJSON(object: any): EchoMsg;
                 toJSON(message: EchoMsg): unknown;
                 fromPartial<I extends {
@@ -118,6 +134,8 @@ export declare const EchoerDefinition: {
             readonly responseType: {
                 encode(message: EchoMsg, writer?: _m0.Writer): _m0.Writer;
                 decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg;
+                encodeTransform(source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<EchoMsg>;
                 fromJSON(object: any): EchoMsg;
                 toJSON(message: EchoMsg): unknown;
                 fromPartial<I extends {
@@ -135,6 +153,8 @@ export declare const EchoerDefinition: {
             readonly requestType: {
                 encode(message: EchoMsg, writer?: _m0.Writer): _m0.Writer;
                 decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg;
+                encodeTransform(source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<EchoMsg>;
                 fromJSON(object: any): EchoMsg;
                 toJSON(message: EchoMsg): unknown;
                 fromPartial<I extends {
@@ -147,6 +167,8 @@ export declare const EchoerDefinition: {
             readonly responseType: {
                 encode(message: EchoMsg, writer?: _m0.Writer): _m0.Writer;
                 decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg;
+                encodeTransform(source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<EchoMsg>;
                 fromJSON(object: any): EchoMsg;
                 toJSON(message: EchoMsg): unknown;
                 fromPartial<I extends {
@@ -158,13 +180,144 @@ export declare const EchoerDefinition: {
             readonly responseStream: true;
             readonly options: {};
         };
+        /** RpcStream opens a nested rpc call stream. */
+        readonly rpcStream: {
+            readonly name: "RpcStream";
+            readonly requestType: {
+                encode(message: RpcStreamPacket, writer?: _m0.Writer): _m0.Writer;
+                decode(input: Uint8Array | _m0.Reader, length?: number | undefined): RpcStreamPacket;
+                encodeTransform(source: AsyncIterable<RpcStreamPacket | RpcStreamPacket[]> | Iterable<RpcStreamPacket | RpcStreamPacket[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<RpcStreamPacket>;
+                fromJSON(object: any): RpcStreamPacket;
+                toJSON(message: RpcStreamPacket): unknown;
+                fromPartial<I_1 extends {
+                    body?: ({
+                        init?: {
+                            componentId?: string | undefined;
+                        } | undefined;
+                    } & {
+                        $case: "init";
+                    }) | ({
+                        ack?: {
+                            error?: string | undefined;
+                        } | undefined;
+                    } & {
+                        $case: "ack";
+                    }) | ({
+                        data?: Uint8Array | undefined;
+                    } & {
+                        $case: "data";
+                    }) | undefined;
+                } & {
+                    body?: ({
+                        init?: {
+                            componentId?: string | undefined;
+                        } | undefined;
+                    } & {
+                        $case: "init";
+                    } & {
+                        init?: ({
+                            componentId?: string | undefined;
+                        } & {
+                            componentId?: string | undefined;
+                        } & Record<Exclude<keyof I_1["body"]["init"], "componentId">, never>) | undefined;
+                        $case: "init";
+                    } & Record<Exclude<keyof I_1["body"], "$case" | "init">, never>) | ({
+                        ack?: {
+                            error?: string | undefined;
+                        } | undefined;
+                    } & {
+                        $case: "ack";
+                    } & {
+                        ack?: ({
+                            error?: string | undefined;
+                        } & {
+                            error?: string | undefined;
+                        } & Record<Exclude<keyof I_1["body"]["ack"], "error">, never>) | undefined;
+                        $case: "ack";
+                    } & Record<Exclude<keyof I_1["body"], "$case" | "ack">, never>) | ({
+                        data?: Uint8Array | undefined;
+                    } & {
+                        $case: "data";
+                    } & {
+                        data?: Uint8Array | undefined;
+                        $case: "data";
+                    } & Record<Exclude<keyof I_1["body"], "$case" | "data">, never>) | undefined;
+                } & Record<Exclude<keyof I_1, "body">, never>>(object: I_1): RpcStreamPacket;
+            };
+            readonly requestStream: true;
+            readonly responseType: {
+                encode(message: RpcStreamPacket, writer?: _m0.Writer): _m0.Writer;
+                decode(input: Uint8Array | _m0.Reader, length?: number | undefined): RpcStreamPacket;
+                encodeTransform(source: AsyncIterable<RpcStreamPacket | RpcStreamPacket[]> | Iterable<RpcStreamPacket | RpcStreamPacket[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<RpcStreamPacket>;
+                fromJSON(object: any): RpcStreamPacket;
+                toJSON(message: RpcStreamPacket): unknown;
+                fromPartial<I_1 extends {
+                    body?: ({
+                        init?: {
+                            componentId?: string | undefined;
+                        } | undefined;
+                    } & {
+                        $case: "init";
+                    }) | ({
+                        ack?: {
+                            error?: string | undefined;
+                        } | undefined;
+                    } & {
+                        $case: "ack";
+                    }) | ({
+                        data?: Uint8Array | undefined;
+                    } & {
+                        $case: "data";
+                    }) | undefined;
+                } & {
+                    body?: ({
+                        init?: {
+                            componentId?: string | undefined;
+                        } | undefined;
+                    } & {
+                        $case: "init";
+                    } & {
+                        init?: ({
+                            componentId?: string | undefined;
+                        } & {
+                            componentId?: string | undefined;
+                        } & Record<Exclude<keyof I_1["body"]["init"], "componentId">, never>) | undefined;
+                        $case: "init";
+                    } & Record<Exclude<keyof I_1["body"], "$case" | "init">, never>) | ({
+                        ack?: {
+                            error?: string | undefined;
+                        } | undefined;
+                    } & {
+                        $case: "ack";
+                    } & {
+                        ack?: ({
+                            error?: string | undefined;
+                        } & {
+                            error?: string | undefined;
+                        } & Record<Exclude<keyof I_1["body"]["ack"], "error">, never>) | undefined;
+                        $case: "ack";
+                    } & Record<Exclude<keyof I_1["body"], "$case" | "ack">, never>) | ({
+                        data?: Uint8Array | undefined;
+                    } & {
+                        $case: "data";
+                    } & {
+                        data?: Uint8Array | undefined;
+                        $case: "data";
+                    } & Record<Exclude<keyof I_1["body"], "$case" | "data">, never>) | undefined;
+                } & Record<Exclude<keyof I_1, "body">, never>>(object: I_1): RpcStreamPacket;
+            };
+            readonly responseStream: true;
+            readonly options: {};
+        };
     };
 };
 interface Rpc {
     request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
-    clientStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Promise<Uint8Array>;
-    serverStreamingRequest(service: string, method: string, data: Uint8Array): Observable<Uint8Array>;
-    bidirectionalStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Observable<Uint8Array>;
+    clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
+    serverStreamingRequest(service: string, method: string, data: Uint8Array): AsyncIterable<Uint8Array>;
+    bidirectionalStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;
 }
 declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {

package/dist/echo/echo.pb.js

@@ -1,7 +1,8 @@
 /* eslint-disable */
 import Long from 'long';
+import { EchoMsg as EchoMsg1 } from './echo.pb.js';
+import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js';
 import * as _m0 from 'protobufjs/minimal';
-import { map } from 'rxjs/operators';
 export const protobufPackage = 'echo';
 function createBaseEchoMsg() {
     return { body: '' };
@@ -30,6 +31,34 @@ export const EchoMsg = {
         }
         return message;
     },
+    // encodeTransform encodes a source of message objects.
+    // Transform<EchoMsg, Uint8Array>
+    async *encodeTransform(source) {
+        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) {
+        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) {
         return {
             body: isSet(object.body) ? String(object.body) : '',
@@ -53,26 +82,32 @@ export class EchoerClientImpl {
         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) {
-        const data = EchoMsg.encode(request).finish();
+        const data = EchoMsg1.encode(request).finish();
         const promise = this.rpc.request('echo.Echoer', 'Echo', data);
-        return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
+        return promise.then((data) => EchoMsg1.decode(new _m0.Reader(data)));
     }
     EchoServerStream(request) {
-        const data = EchoMsg.encode(request).finish();
+        const data = EchoMsg1.encode(request).finish();
         const result = this.rpc.serverStreamingRequest('echo.Echoer', 'EchoServerStream', data);
-        return result.pipe(map((data) => EchoMsg.decode(new _m0.Reader(data))));
+        return EchoMsg1.decodeTransform(result);
     }
     EchoClientStream(request) {
-        const data = request.pipe(map((request) => EchoMsg.encode(request).finish()));
+        const data = EchoMsg1.encodeTransform(request);
         const promise = this.rpc.clientStreamingRequest('echo.Echoer', 'EchoClientStream', data);
-        return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
+        return promise.then((data) => EchoMsg1.decode(new _m0.Reader(data)));
     }
     EchoBidiStream(request) {
-        const data = request.pipe(map((request) => EchoMsg.encode(request).finish()));
+        const data = EchoMsg1.encodeTransform(request);
         const result = this.rpc.bidirectionalStreamingRequest('echo.Echoer', 'EchoBidiStream', data);
-        return result.pipe(map((data) => EchoMsg.decode(new _m0.Reader(data))));
+        return EchoMsg1.decodeTransform(result);
+    }
+    RpcStream(request) {
+        const data = RpcStreamPacket.encodeTransform(request);
+        const result = this.rpc.bidirectionalStreamingRequest('echo.Echoer', 'RpcStream', data);
+        return RpcStreamPacket.decodeTransform(result);
     }
 }
 export const EchoerDefinition = {
@@ -82,36 +117,45 @@ export const EchoerDefinition = {
         /** Echo returns the given message. */
         echo: {
             name: 'Echo',
-            requestType: EchoMsg,
+            requestType: EchoMsg1,
             requestStream: false,
-            responseType: EchoMsg,
+            responseType: EchoMsg1,
             responseStream: false,
             options: {},
         },
         /** EchoServerStream is an example of a server -> client one-way stream. */
         echoServerStream: {
             name: 'EchoServerStream',
-            requestType: EchoMsg,
+            requestType: EchoMsg1,
             requestStream: false,
-            responseType: EchoMsg,
+            responseType: EchoMsg1,
             responseStream: true,
             options: {},
         },
         /** EchoClientStream is an example of client->server one-way stream. */
         echoClientStream: {
             name: 'EchoClientStream',
-            requestType: EchoMsg,
+            requestType: EchoMsg1,
             requestStream: true,
-            responseType: EchoMsg,
+            responseType: EchoMsg1,
             responseStream: false,
             options: {},
         },
         /** EchoBidiStream is an example of a two-way stream. */
         echoBidiStream: {
             name: 'EchoBidiStream',
-            requestType: EchoMsg,
+            requestType: EchoMsg1,
+            requestStream: true,
+            responseType: EchoMsg1,
+            responseStream: true,
+            options: {},
+        },
+        /** RpcStream opens a nested rpc call stream. */
+        rpcStream: {
+            name: 'RpcStream',
+            requestType: RpcStreamPacket,
             requestStream: true,
-            responseType: EchoMsg,
+            responseType: RpcStreamPacket,
             responseStream: true,
             options: {},
         },

package/dist/echo/server.d.ts

@@ -1,8 +1,12 @@
-import { Observable } from 'rxjs';
 import { Echoer, EchoMsg } from './echo.pb.js';
+import { Server } from '../srpc/server.js';
+import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js';
 export declare class EchoerServer implements Echoer {
+    private proxyServer?;
+    constructor(proxyServer?: Server);
     Echo(request: EchoMsg): Promise<EchoMsg>;
-    EchoServerStream(request: EchoMsg): Observable<EchoMsg>;
-    EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg>;
-    EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg>;
+    EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>;
+    EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>;
+    EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>;
+    RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket>;
 }

package/dist/echo/server.js

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