starpc 0.25.2 → 0.25.3

package/dist/rpcstream/rpcstream.d.ts

@@ -5,7 +5,7 @@ import { OpenStreamFunc, PacketStream } from '../srpc/stream.js';
 export type RpcStreamCaller = (request: AsyncIterable<RpcStreamPacket>) => AsyncIterable<RpcStreamPacket>;
 export declare function openRpcStream(componentId: string, caller: RpcStreamCaller, waitAck?: boolean): Promise<PacketStream>;
 export declare function buildRpcStreamOpenStream(componentId: string, caller: RpcStreamCaller): OpenStreamFunc;
-export type RpcStreamHandler = (stream: PacketStream) => void;
+export type RpcStreamHandler = (stream: PacketStream) => Promise<void>;
 export type RpcStreamGetter = (componentId: string) => Promise<RpcStreamHandler | null>;
 export declare function handleRpcStream(packetRx: AsyncIterator<RpcStreamPacket>, getter: RpcStreamGetter): AsyncIterable<RpcStreamPacket>;
 export declare class RpcStream implements PacketStream {

package/dist/rpcstream/rpcstream.js

@@ -86,7 +86,9 @@ export async function* handleRpcStream(packetRx, getter) {
     const packetTx = pushable({ objectMode: true });
     // start the handler
     const rpcStream = new RpcStream(packetTx, packetRx);
-    handler(rpcStream);
+    handler(rpcStream)
+        .catch((err) => packetTx.end(err))
+        .then(() => packetTx.end());
     // process packets
     for await (const packet of packetTx) {
         yield* [packet];

package/dist/srpc/channel.js

@@ -6,6 +6,7 @@ import { ERR_STREAM_IDLE } from './errors.js';
 // NOTE: there is no way to tell if a BroadcastChannel or MessagePort is closed.
 // This implementation sends a "closed" message when close() is called.
 // However: if the remote is removed w/o closing cleanly, the stream will be left open!
+// Enable keepAliveMs and idleTimeoutMs to mitigate this issue with keep-alive messages.
 export class ChannelStream {
     // isAcked checks if the stream is acknowledged by the remote.
     get isAcked() {

package/dist/srpc/client.js

@@ -85,8 +85,8 @@ export class Client {
             call.close(new Error(ERR_RPC_ABORT));
         });
         pipe(stream, decodePacketSource, call, encodePacketSource, stream)
-            .then(() => call.close())
-            .catch((err) => call.close(err));
+            .catch((err) => call.close(err))
+            .then(() => call.close());
         await call.writeCallStart(data || undefined);
         return call;
     }

package/dist/srpc/server.js

@@ -9,7 +9,12 @@ export class Server {
     // rpcStreamHandler implements the RpcStreamHandler interface.
     // uses handlePacketDuplex (expects 1 buf = 1 Packet)
     get rpcStreamHandler() {
-        return this.handlePacketStream.bind(this);
+        return async (stream) => {
+            const rpc = this.startRpc();
+            return pipe(stream, decodePacketSource, rpc, encodePacketSource, stream)
+                .catch((err) => rpc.close(err))
+                .then(() => rpc.close());
+        };
     }
     // startRpc starts a new server-side RPC.
     // the returned RPC handles incoming Packets.

package/dist/srpc/websocket.js

@@ -10,7 +10,9 @@ export class WebSocketConn extends StreamConn {
         const socketDuplex = duplex(socket);
         pipe(socketDuplex, this, 
         // it-ws only supports sending Uint8Array.
-        combineUint8ArrayListTransform(), socketDuplex);
+        combineUint8ArrayListTransform(), socketDuplex)
+            .catch((err) => this.close(err))
+            .then(() => this.close());
     }
     // getSocket returns the websocket.
     getSocket() {

package/package.json

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

package/srpc/channel.ts

@@ -42,6 +42,7 @@ export interface ChannelStreamOpts {
 // NOTE: there is no way to tell if a BroadcastChannel or MessagePort is closed.
 // This implementation sends a "closed" message when close() is called.
 // However: if the remote is removed w/o closing cleanly, the stream will be left open!
+// Enable keepAliveMs and idleTimeoutMs to mitigate this issue with keep-alive messages.
 export class ChannelStream<T = Uint8Array>
   implements Duplex<AsyncGenerator<T>, Source<T>, Promise<void>>
 {

package/srpc/client.ts

@@ -122,8 +122,8 @@ export class Client implements TsProtoRpc {
       call.close(new Error(ERR_RPC_ABORT))
     })
     pipe(stream, decodePacketSource, call, encodePacketSource, stream)
-      .then(() => call.close())
       .catch((err) => call.close(err))
+      .then(() => call.close())
     await call.writeCallStart(data || undefined)
     return call
   }

package/srpc/server.ts

@@ -19,7 +19,12 @@ export class Server implements StreamHandler {
   // rpcStreamHandler implements the RpcStreamHandler interface.
   // uses handlePacketDuplex (expects 1 buf = 1 Packet)
   public get rpcStreamHandler(): RpcStreamHandler {
-    return this.handlePacketStream.bind(this)
+    return async (stream: PacketStream) => {
+      const rpc = this.startRpc()
+      return pipe(stream, decodePacketSource, rpc, encodePacketSource, stream)
+        .catch((err: Error) => rpc.close(err))
+        .then(() => rpc.close())
+    }
   }
 
   // startRpc starts a new server-side RPC.

package/srpc/websocket.ts

@@ -24,6 +24,8 @@ export class WebSocketConn extends StreamConn {
       combineUint8ArrayListTransform(),
       socketDuplex,
     )
+      .catch((err) => this.close(err))
+      .then(() => this.close())
   }
 
   // getSocket returns the websocket.