starpc 0.22.2 → 0.22.4

package/dist/rpcstream/rpcstream.d.ts

@@ -7,13 +7,13 @@ export declare function openRpcStream(componentId: string, caller: RpcStreamCall
 export declare function buildRpcStreamOpenStream(componentId: string, caller: RpcStreamCaller): OpenStreamFunc;
 export type RpcStreamHandler = (stream: Stream) => void;
 export type RpcStreamGetter = (componentId: string) => Promise<RpcStreamHandler | null>;
-export declare function handleRpcStream(packetStream: AsyncIterator<RpcStreamPacket>, getter: RpcStreamGetter): AsyncIterable<RpcStreamPacket>;
+export declare function handleRpcStream(packetRx: AsyncIterator<RpcStreamPacket>, getter: RpcStreamGetter): AsyncIterable<RpcStreamPacket>;
 export declare class RpcStream implements Stream {
     readonly source: AsyncGenerator<Uint8Array>;
     readonly sink: Sink<Source<Uint8Array>, Promise<void>>;
-    private readonly _packetStream;
-    private readonly _packetSink;
-    constructor(packetSink: Pushable<RpcStreamPacket>, packetStream: AsyncIterator<RpcStreamPacket>);
+    private readonly _packetRx;
+    private readonly _packetTx;
+    constructor(packetTx: Pushable<RpcStreamPacket>, packetRx: AsyncIterator<RpcStreamPacket>);
     private _createSink;
     private _createSource;
 }

package/dist/rpcstream/rpcstream.js

@@ -2,17 +2,17 @@ import { pushable } from 'it-pushable';
 // openRpcStream attempts to open a stream over a RPC call.
 // if waitAck is set, waits for the remote to ack the stream before returning.
 export async function openRpcStream(componentId, caller, waitAck) {
-    const packetSink = pushable({ objectMode: true });
-    const packetSource = caller(packetSink);
+    const packetTx = pushable({ objectMode: true });
+    const packetRx = caller(packetTx);
     // write the component id
-    packetSink.push({
+    packetTx.push({
         body: {
             $case: 'init',
             init: { componentId },
         },
     });
     // construct packet stream
-    const packetIt = packetSource[Symbol.asyncIterator]();
+    const packetIt = packetRx[Symbol.asyncIterator]();
     // wait for ack, if set.
     if (waitAck) {
         const ackPacketIt = await packetIt.next();
@@ -31,7 +31,7 @@ export async function openRpcStream(componentId, caller, waitAck) {
         }
     }
     // build & return the data stream
-    return new RpcStream(packetSink, packetIt);
+    return new RpcStream(packetTx, packetIt);
 }
 // buildRpcStreamOpenStream builds a OpenStream func with a RpcStream.
 export function buildRpcStreamOpenStream(componentId, caller) {
@@ -40,9 +40,9 @@ export function buildRpcStreamOpenStream(componentId, caller) {
     };
 }
 // handleRpcStream handles an incoming RPC stream (remote is the initiator).
-export async function* handleRpcStream(packetStream, getter) {
+export async function* handleRpcStream(packetRx, getter) {
     // read the component id
-    const initRpcStreamIt = await packetStream.next();
+    const initRpcStreamIt = await packetRx.next();
     if (initRpcStreamIt.done) {
         throw new Error('closed before init received');
     }
@@ -83,23 +83,23 @@ export async function* handleRpcStream(packetStream, getter) {
         throw err;
     }
     // build the outgoing packet sink & the packet source
-    const packetSink = pushable({ objectMode: true });
+    const packetTx = pushable({ objectMode: true });
     // start the handler
-    const rpcStream = new RpcStream(packetSink, packetStream);
+    const rpcStream = new RpcStream(packetTx, packetRx);
     handler(rpcStream);
     // process packets
-    for await (const packet of packetSink) {
+    for await (const packet of packetTx) {
         yield* [packet];
     }
 }
 // RpcStream implements the Stream on top of a RPC call.
 // Note: expects the stream to already have been negotiated.
 export class RpcStream {
-    // packetSink writes packets to the remote.
-    // packetSource receives packets from the remote.
-    constructor(packetSink, packetStream) {
-        this._packetSink = packetSink;
-        this._packetStream = packetStream;
+    // packetTx writes packets to the remote.
+    // packetRx receives packets from the remote.
+    constructor(packetTx, packetRx) {
+        this._packetTx = packetTx;
+        this._packetRx = packetRx;
         this.sink = this._createSink();
         this.source = this._createSource();
     }
@@ -108,23 +108,22 @@ export class RpcStream {
         return async (source) => {
             try {
                 for await (const arr of source) {
-                    this._packetSink.push({
+                    this._packetTx.push({
                         body: { $case: 'data', data: arr },
                     });
                 }
-                this._packetSink.end();
+                this._packetTx.end();
             }
             catch (err) {
-                this._packetSink.end(err);
+                this._packetTx.end(err);
             }
         };
     }
     // _createSource initializes the source field.
     _createSource() {
-        const packetSource = this._packetStream;
-        return (async function* () {
+        return (async function* (packetRx) {
             while (true) {
-                const msgIt = await packetSource.next();
+                const msgIt = await packetRx.next();
                 if (msgIt.done) {
                     return;
                 }
@@ -144,6 +143,6 @@ export class RpcStream {
                         break;
                 }
             }
-        })();
+        })(this._packetRx);
     }
 }

package/dist/srpc/client.js

@@ -44,7 +44,7 @@ export class Client {
             .then(async (call) => {
             return writeToPushable(call.rpcDataSource, serverData);
         })
-            .catch(serverData.throw.bind(serverData));
+            .catch(err => serverData.end(err));
         return serverData;
     }
     // bidirectionalStreamingRequest starts a two-way streaming request.
@@ -57,13 +57,13 @@ export class Client {
                 for await (const message of call.rpcDataSource) {
                     serverData.push(message);
                 }
+                serverData.end();
             }
             catch (err) {
-                serverData.throw(err);
+                serverData.end(err);
             }
-            serverData.end();
         })
-            .catch(serverData.throw.bind(serverData));
+            .catch(err => serverData.end(err));
         return serverData;
     }
     // startRpc is a common utility function to begin a rpc call.

package/dist/srpc/common-rpc.js

@@ -120,11 +120,11 @@ export class CommonRPC {
             return;
         }
         this.closed = true;
+        this._rpcDataSource.end(err);
         try {
             await this.writeCallCancel();
         }
         finally {
-            this._rpcDataSource.end(err);
             // note: don't pass error to _source here.
             this._source.end();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.22.2",
+  "version": "0.22.4",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/client.ts

@@ -70,7 +70,7 @@ export class Client implements TsProtoRpc {
       .then(async (call) => {
         return writeToPushable(call.rpcDataSource, serverData)
       })
-      .catch(serverData.throw.bind(serverData))
+      .catch(err => serverData.end(err))
     return serverData
   }
 
@@ -89,12 +89,12 @@ export class Client implements TsProtoRpc {
           for await (const message of call.rpcDataSource) {
             serverData.push(message)
           }
+          serverData.end()
         } catch (err) {
-          serverData.throw(err as Error)
+          serverData.end(err as Error)
         }
-        serverData.end()
       })
-      .catch(serverData.throw.bind(serverData))
+      .catch(err => serverData.end(err))
     return serverData
   }
 

package/srpc/common-rpc.ts

@@ -157,10 +157,10 @@ export class CommonRPC {
       return
     }
     this.closed = true
+    this._rpcDataSource.end(err)
     try {
       await this.writeCallCancel()
     } finally {
-      this._rpcDataSource.end(err)
       // note: don't pass error to _source here.
       this._source.end()
     }