starpc 0.25.3 → 0.25.5

package/dist/e2e/e2e.js

@@ -13,7 +13,7 @@ async function runRPC() {
     const serverConn = new StreamConn(server, { direction: 'inbound' });
     // pipe clientConn -> messageStream -> serverConn -> messageStream -> clientConn
     const { port1: clientPort, port2: serverPort } = new MessageChannel();
-    const opts = { idleTimeoutMs: 250, keepAliveMs: 100 };
+    const opts = {}; // { idleTimeoutMs: 250, keepAliveMs: 100 }
     const clientChannelStream = new ChannelStream('client', clientPort, opts);
     const serverChannelStream = new ChannelStream('server', serverPort, opts);
     // Pipe the client traffic via the client end of the MessageChannel.
@@ -30,6 +30,10 @@ async function runRPC() {
     await runClientTest(client);
     await runAbortControllerTest(client);
     await runRpcStreamTest(client);
+    // Make sure we have no uncaught promises
+    await new Promise((resolve) => {
+        setTimeout(resolve, 500);
+    });
     // Close cleanly
     clientConn.close();
     serverConn.close();
@@ -40,6 +44,6 @@ runRPC()
     process.exit(0);
 })
     .catch((err) => {
-    console.error(err);
+    console.error('e2e tests failed', err);
     process.exit(1);
 });

package/dist/echo/client-test.js

@@ -29,24 +29,44 @@ export async function runAbortControllerTest(client) {
     const demoServiceClient = new EchoerClientImpl(client);
     console.log('Testing EchoClientStream with AbortController...');
     let errorReturned = false;
-    const clientAbort = new AbortController();
-    const clientNoopStream = pushable({ objectMode: true });
-    new Promise((resolve) => setTimeout(resolve, 1000)).then(() => {
-        clientAbort.abort();
+    const testRpc = async (rpc) => {
+        const clientAbort = new AbortController();
+        new Promise((resolve) => setTimeout(resolve, 1000)).then(() => {
+            clientAbort.abort();
+        });
+        try {
+            await rpc(clientAbort.signal);
+        }
+        catch (err) {
+            const errMsg = err.message;
+            errorReturned = true;
+            if (errMsg !== ERR_RPC_ABORT) {
+                throw new Error('unexpected error: ' + errMsg);
+            }
+        }
+        if (!errorReturned) {
+            throw new Error('expected aborted rpc to throw error');
+        }
+    };
+    await testRpc(async (signal) => {
+        const clientNoopStream = pushable({ objectMode: true });
+        await demoServiceClient.EchoClientStream(clientNoopStream, signal);
     });
-    try {
-        await demoServiceClient.EchoClientStream(clientNoopStream, clientAbort.signal);
-    }
-    catch (err) {
-        const errMsg = err.message;
-        errorReturned = true;
-        if (errMsg !== ERR_RPC_ABORT) {
-            throw new Error('unexpected error: ' + errMsg);
+    await testRpc(async (signal) => {
+        const stream = demoServiceClient.EchoServerStream({ body: 'test' }, signal);
+        let gotMsgs = 0;
+        try {
+            for await (const msg of stream) {
+                gotMsgs++;
+            }
         }
-    }
-    if (!errorReturned) {
-        throw new Error('expected aborted rpc to throw error');
-    }
+        catch (err) {
+            if (gotMsgs < 3) {
+                throw new Error('expected at least three messages before error');
+            }
+            throw err;
+        }
+    });
 }
 // runRpcStreamTest tests a RPCStream.
 export async function runRpcStreamTest(client) {

package/dist/srpc/client.js

@@ -28,7 +28,7 @@ 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;
@@ -41,11 +41,7 @@ export class Client {
     serverStreamingRequest(service, method, data, abortSignal) {
         const serverData = pushable({ objectMode: true });
         this.startRpc(service, method, data, abortSignal)
-            .then(async (call) => {
-            const result = writeToPushable(call.rpcDataSource, serverData);
-            result.finally(() => call.close());
-            return result;
-        })
+            .then(async (call) => writeToPushable(call.rpcDataSource, serverData))
             .catch((err) => serverData.end(err));
         return serverData;
     }
@@ -54,7 +50,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 +63,7 @@ export class Client {
                 call.close();
             }
             catch (err) {
-                call.close(err);
-                throw err;
+                handleErr(err);
             }
         })
             .catch((err) => serverData.end(err));
@@ -87,7 +86,7 @@ export class Client {
         pipe(stream, decodePacketSource, call, encodePacketSource, stream)
             .catch((err) => call.close(err))
             .then(() => call.close());
-        await call.writeCallStart(data || undefined);
+        await call.writeCallStart(data ?? undefined);
         return call;
     }
 }

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

@@ -11,6 +11,7 @@ export declare class CommonRPC {
     protected method?: string;
     private closed?;
     constructor();
+    get isClosed(): boolean | Error;
     writeCallData(data?: Uint8Array, complete?: boolean, error?: string): Promise<void>;
     writeCallCancel(): Promise<void>;
     writeCallDataFromSource(dataSource: AsyncIterable<Uint8Array>): Promise<void>;
@@ -22,6 +23,5 @@ export declare class CommonRPC {
     handleCallData(packet: Partial<CallData>): Promise<void>;
     handleCallCancel(): Promise<void>;
     close(err?: Error): Promise<void>;
-    closeWrite(): void;
     private _createSink;
 }

package/dist/srpc/common-rpc.js

@@ -16,6 +16,10 @@ export class CommonRPC {
         this.source = this._source;
         this.rpcDataSource = this._rpcDataSource;
     }
+    // isClosed returns one of: true (closed w/o error), Error (closed w/ error), or false (not closed).
+    get isClosed() {
+        return this.closed ?? false;
+    }
     // writeCallData writes the call data packet.
     async writeCallData(data, complete, error) {
         const callData = {
@@ -130,18 +134,12 @@ export class CommonRPC {
         if (this.closed) {
             return;
         }
-        this.closed = true;
-        // note: don't pass error to _source here.
-        if (err) {
-            await this.writeCallCancel();
-        }
+        this.closed = err ?? true;
+        // note: this does nothing if _source is already ended.
+        await this.writeCallCancel();
         this._source.end();
         this._rpcDataSource.end(err);
     }
-    // closeWrite closes the call for writing.
-    closeWrite() {
-        this._source.end();
-    }
     // _createSink returns a value for the sink field.
     _createSink() {
         return async (source) => {

package/dist/srpc/pushable.js

@@ -1,4 +1,6 @@
 // writeToPushable writes the incoming server data to the pushable.
+//
+// this will not throw an error: it instead ends out w/ the error.
 export async function writeToPushable(dataSource, out) {
     try {
         for await (const data of dataSource) {
@@ -8,7 +10,6 @@ export async function writeToPushable(dataSource, out) {
     }
     catch (err) {
         out.end(err);
-        throw err;
     }
 }
 export function buildPushableSink(target) {

package/e2e/e2e.ts

@@ -25,7 +25,7 @@ async function runRPC() {
 
   // pipe clientConn -> messageStream -> serverConn -> messageStream -> clientConn
   const { port1: clientPort, port2: serverPort } = new MessageChannel()
-  const opts: ChannelStreamOpts = { idleTimeoutMs: 250, keepAliveMs: 100 }
+  const opts: ChannelStreamOpts = {} // { idleTimeoutMs: 250, keepAliveMs: 100 }
   const clientChannelStream = new ChannelStream('client', clientPort, opts)
   const serverChannelStream = new ChannelStream('server', serverPort, opts)
 
@@ -57,6 +57,11 @@ async function runRPC() {
   await runAbortControllerTest(client)
   await runRpcStreamTest(client)
 
+  // Make sure we have no uncaught promises
+  await new Promise<void>((resolve) => {
+    setTimeout(resolve, 500)
+  })
+
   // Close cleanly
   clientConn.close()
   serverConn.close()
@@ -68,6 +73,6 @@ runRPC()
     process.exit(0)
   })
   .catch((err) => {
-    console.error(err)
+    console.error('e2e tests failed', err)
     process.exit(1)
   })

package/echo/client-test.ts

@@ -36,26 +36,45 @@ export async function runAbortControllerTest(client: Client) {
 
   console.log('Testing EchoClientStream with AbortController...')
   let errorReturned = false
-  const clientAbort = new AbortController()
-  const clientNoopStream = pushable<EchoMsg>({ objectMode: true })
-  new Promise((resolve) => setTimeout(resolve, 1000)).then(() => {
-    clientAbort.abort()
-  })
-  try {
-    await demoServiceClient.EchoClientStream(
-      clientNoopStream,
-      clientAbort.signal,
-    )
-  } catch (err) {
-    const errMsg = (err as Error).message
-    errorReturned = true
-    if (errMsg !== ERR_RPC_ABORT) {
-      throw new Error('unexpected error: ' + errMsg)
+
+  const testRpc = async (rpc: (signal: AbortSignal) => Promise<void>) => {
+    const clientAbort = new AbortController()
+    new Promise((resolve) => setTimeout(resolve, 1000)).then(() => {
+      clientAbort.abort()
+    })
+    try {
+      await rpc(clientAbort.signal)
+    } catch (err) {
+      const errMsg = (err as Error).message
+      errorReturned = true
+      if (errMsg !== ERR_RPC_ABORT) {
+        throw new Error('unexpected error: ' + errMsg)
+      }
+    }
+    if (!errorReturned) {
+      throw new Error('expected aborted rpc to throw error')
     }
   }
-  if (!errorReturned) {
-    throw new Error('expected aborted rpc to throw error')
-  }
+
+  await testRpc(async (signal) => {
+    const clientNoopStream = pushable<EchoMsg>({ objectMode: true })
+    await demoServiceClient.EchoClientStream(clientNoopStream, signal)
+  })
+
+  await testRpc(async (signal) => {
+    const stream = demoServiceClient.EchoServerStream({ body: 'test' }, signal)
+    let gotMsgs = 0
+    try {
+      for await (const msg of stream) {
+        gotMsgs++
+      }
+    } catch (err) {
+      if (gotMsgs < 3) {
+        throw new Error('expected at least three messages before error')
+      }
+      throw err
+    }
+  })
 }
 
 // runRpcStreamTest tests a RPCStream.

package/package.json

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

package/srpc/client.ts

@@ -48,7 +48,7 @@ export class Client implements TsProtoRpc {
     abortSignal?: AbortSignal,
   ): Promise<Uint8Array> {
     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
@@ -67,11 +67,7 @@ export class Client implements TsProtoRpc {
   ): AsyncIterable<Uint8Array> {
     const serverData: Pushable<Uint8Array> = pushable({ objectMode: true })
     this.startRpc(service, method, data, abortSignal)
-      .then(async (call) => {
-        const result = writeToPushable(call.rpcDataSource, serverData)
-        result.finally(() => call.close())
-        return result
-      })
+      .then(async (call) => writeToPushable(call.rpcDataSource, serverData))
       .catch((err) => serverData.end(err))
     return serverData
   }
@@ -86,7 +82,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 +94,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))
@@ -124,7 +123,7 @@ export class Client implements TsProtoRpc {
     pipe(stream, decodePacketSource, call, encodePacketSource, stream)
       .catch((err) => call.close(err))
       .then(() => call.close())
-    await call.writeCallStart(data || undefined)
+    await call.writeCallStart(data ?? undefined)
     return call
   }
 }

package/srpc/common-rpc.ts

@@ -30,7 +30,7 @@ export class CommonRPC {
   protected method?: string
 
   // closed indicates this rpc has been closed already.
-  private closed?: boolean
+  private closed?: true | Error
 
   constructor() {
     this.sink = this._createSink()
@@ -38,6 +38,11 @@ export class CommonRPC {
     this.rpcDataSource = this._rpcDataSource
   }
 
+  // isClosed returns one of: true (closed w/o error), Error (closed w/ error), or false (not closed).
+  public get isClosed(): boolean | Error {
+    return this.closed ?? false
+  }
+
   // writeCallData writes the call data packet.
   public async writeCallData(
     data?: Uint8Array,
@@ -168,20 +173,13 @@ export class CommonRPC {
     if (this.closed) {
       return
     }
-    this.closed = true
-    // note: don't pass error to _source here.
-    if (err) {
-      await this.writeCallCancel()
-    }
+    this.closed = err ?? true
+    // note: this does nothing if _source is already ended.
+    await this.writeCallCancel()
     this._source.end()
     this._rpcDataSource.end(err)
   }
 
-  // closeWrite closes the call for writing.
-  public closeWrite() {
-    this._source.end()
-  }
-
   // _createSink returns a value for the sink field.
   private _createSink(): Sink<Source<Packet>> {
     return async (source: Source<Packet>) => {

package/srpc/pushable.ts

@@ -2,6 +2,8 @@ import { Pushable } from 'it-pushable'
 import { Sink, Source } from 'it-stream-types'
 
 // writeToPushable writes the incoming server data to the pushable.
+//
+// this will not throw an error: it instead ends out w/ the error.
 export async function writeToPushable<T>(
   dataSource: AsyncIterable<T>,
   out: Pushable<T>,
@@ -13,7 +15,6 @@ export async function writeToPushable<T>(
     out.end()
   } catch (err) {
     out.end(err as Error)
-    throw err
   }
 }