starpc 0.25.2 → 0.25.4

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

@@ -28,7 +28,8 @@ export class Client {
     // clientStreamingRequest starts a client side streaming request.
     async clientStreamingRequest(service, method, data, abortSignal) {
         const call = await this.startRpc(service, method, null, abortSignal);
-        call.writeCallDataFromSource(data);
+        call.writeCallDataFromSource(data)
+            .catch(err => call.close(err));
         for await (const data of call.rpcDataSource) {
             call.close();
             return data;
@@ -43,7 +44,8 @@ export class Client {
         this.startRpc(service, method, data, abortSignal)
             .then(async (call) => {
             const result = writeToPushable(call.rpcDataSource, serverData);
-            result.finally(() => call.close());
+            result.catch((err) => call.close(err));
+            result.then(() => call.close());
             return result;
         })
             .catch((err) => serverData.end(err));
@@ -54,7 +56,11 @@ export class Client {
         const serverData = pushable({ objectMode: true });
         this.startRpc(service, method, null, abortSignal)
             .then(async (call) => {
-            call.writeCallDataFromSource(data).catch((err) => call.close(err));
+            const handleErr = (err) => {
+                serverData.end(err);
+                call.close(err);
+            };
+            call.writeCallDataFromSource(data).catch(handleErr);
             try {
                 for await (const message of call.rpcDataSource) {
                     serverData.push(message);
@@ -63,8 +69,7 @@ export class Client {
                 call.close();
             }
             catch (err) {
-                call.close(err);
-                throw err;
+                handleErr(err);
             }
         })
             .catch((err) => serverData.end(err));
@@ -85,8 +90,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.4",
   "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

@@ -49,6 +49,7 @@ export class Client implements TsProtoRpc {
   ): Promise<Uint8Array> {
     const call = await this.startRpc(service, method, null, abortSignal)
     call.writeCallDataFromSource(data)
+      .catch(err => call.close(err))
     for await (const data of call.rpcDataSource) {
       call.close()
       return data
@@ -69,7 +70,8 @@ export class Client implements TsProtoRpc {
     this.startRpc(service, method, data, abortSignal)
       .then(async (call) => {
         const result = writeToPushable(call.rpcDataSource, serverData)
-        result.finally(() => call.close())
+        result.catch((err) => call.close(err))
+        result.then(() => call.close())
         return result
       })
       .catch((err) => serverData.end(err))
@@ -86,7 +88,11 @@ export class Client implements TsProtoRpc {
     const serverData: Pushable<Uint8Array> = pushable({ objectMode: true })
     this.startRpc(service, method, null, abortSignal)
       .then(async (call) => {
-        call.writeCallDataFromSource(data).catch((err) => call.close(err))
+        const handleErr = (err: Error) => {
+          serverData.end(err)
+          call.close(err)
+        }
+        call.writeCallDataFromSource(data).catch(handleErr)
         try {
           for await (const message of call.rpcDataSource) {
             serverData.push(message)
@@ -94,8 +100,7 @@ export class Client implements TsProtoRpc {
           serverData.end()
           call.close()
         } catch (err) {
-          call.close(err as Error)
-          throw err
+          handleErr(err as Error)
         }
       })
       .catch((err) => serverData.end(err))
@@ -122,8 +127,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.