starpc 0.15.3 → 0.16.0

package/Makefile

@@ -110,8 +110,9 @@ 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=useDate=true \
+		--ts_proto_opt=useAbortSignal=true \
 		--ts_proto_opt=useAsyncIterable=true \
+		--ts_proto_opt=useDate=true \
 		--proto_path $$(pwd)/vendor \
 		--print_structure \
 		--only_specified_files \

package/dist/e2e/mock/mock.pb.d.ts

@@ -21,7 +21,7 @@ export declare const MockMsg: {
 /** Mock service mocks some RPCs for the e2e tests. */
 export interface Mock {
     /** MockRequest runs a mock unary request. */
-    MockRequest(request: MockMsg): Promise<MockMsg>;
+    MockRequest(request: MockMsg, abortSignal?: AbortSignal): Promise<MockMsg>;
 }
 export declare class MockClientImpl implements Mock {
     private readonly rpc;
@@ -29,7 +29,7 @@ export declare class MockClientImpl implements Mock {
     constructor(rpc: Rpc, opts?: {
         service?: string;
     });
-    MockRequest(request: MockMsg): Promise<MockMsg>;
+    MockRequest(request: MockMsg, abortSignal?: AbortSignal): Promise<MockMsg>;
 }
 /** Mock service mocks some RPCs for the e2e tests. */
 export type MockDefinition = typeof MockDefinition;
@@ -73,7 +73,7 @@ export declare const MockDefinition: {
     };
 };
 interface Rpc {
-    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+    request(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): Promise<Uint8Array>;
 }
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export 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/e2e/mock/mock.pb.js

@@ -77,9 +77,9 @@ export class MockClientImpl {
         this.rpc = rpc;
         this.MockRequest = this.MockRequest.bind(this);
     }
-    MockRequest(request) {
+    MockRequest(request, abortSignal) {
         const data = MockMsg.encode(request).finish();
-        const promise = this.rpc.request(this.service, 'MockRequest', data);
+        const promise = this.rpc.request(this.service, 'MockRequest', data, abortSignal || undefined);
         return promise.then((data) => MockMsg.decode(new _m0.Reader(data)));
     }
 }

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

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

package/dist/echo/client-test.js

@@ -1,4 +1,4 @@
-import { Client } from '../srpc/index.js';
+import { Client, ERR_RPC_ABORT } from '../srpc/index.js';
 import { EchoerClientImpl } from './echo.pb.js';
 import { pushable } from 'it-pushable';
 import { buildRpcStreamOpenStream } from '../rpcstream/rpcstream.js';
@@ -24,6 +24,30 @@ export async function runClientTest(client) {
         console.log('server: output', msg.body);
     }
 }
+// runAbortControllerTest tests aborting a RPC call.
+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();
+    });
+    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);
+        }
+    }
+    if (!errorReturned) {
+        throw new Error('expected aborted rpc to throw error');
+    }
+}
 // runRpcStreamTest tests a RPCStream.
 export async function runRpcStreamTest(client) {
     console.log('Calling RpcStream to open a RPC stream client...');

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

@@ -22,15 +22,15 @@ 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: EchoMsg, abortSignal?: AbortSignal): Promise<EchoMsg>;
     /** EchoServerStream is an example of a server -> client one-way stream. */
-    EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>;
+    EchoServerStream(request: EchoMsg, abortSignal?: AbortSignal): AsyncIterable<EchoMsg>;
     /** EchoClientStream is an example of client->server one-way stream. */
-    EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>;
+    EchoClientStream(request: AsyncIterable<EchoMsg>, abortSignal?: AbortSignal): Promise<EchoMsg>;
     /** EchoBidiStream is an example of a two-way stream. */
-    EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>;
+    EchoBidiStream(request: AsyncIterable<EchoMsg>, abortSignal?: AbortSignal): AsyncIterable<EchoMsg>;
     /** RpcStream opens a nested rpc call stream. */
-    RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket>;
+    RpcStream(request: AsyncIterable<RpcStreamPacket>, abortSignal?: AbortSignal): AsyncIterable<RpcStreamPacket>;
 }
 export declare class EchoerClientImpl implements Echoer {
     private readonly rpc;
@@ -38,11 +38,11 @@ export declare class EchoerClientImpl implements Echoer {
     constructor(rpc: Rpc, opts?: {
         service?: string;
     });
-    Echo(request: EchoMsg): Promise<EchoMsg>;
-    EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>;
-    EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>;
-    EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>;
-    RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket>;
+    Echo(request: EchoMsg, abortSignal?: AbortSignal): Promise<EchoMsg>;
+    EchoServerStream(request: EchoMsg, abortSignal?: AbortSignal): AsyncIterable<EchoMsg>;
+    EchoClientStream(request: AsyncIterable<EchoMsg>, abortSignal?: AbortSignal): Promise<EchoMsg>;
+    EchoBidiStream(request: AsyncIterable<EchoMsg>, abortSignal?: AbortSignal): AsyncIterable<EchoMsg>;
+    RpcStream(request: AsyncIterable<RpcStreamPacket>, abortSignal?: AbortSignal): AsyncIterable<RpcStreamPacket>;
 }
 /** Echoer service returns the given message. */
 export type EchoerDefinition = typeof EchoerDefinition;
@@ -316,10 +316,10 @@ export declare const EchoerDefinition: {
     };
 };
 interface Rpc {
-    request(service: string, method: string, data: Uint8Array): Promise<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>;
+    request(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): Promise<Uint8Array>;
+    clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>, abortSignal?: AbortSignal): Promise<Uint8Array>;
+    serverStreamingRequest(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): AsyncIterable<Uint8Array>;
+    bidirectionalStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>, abortSignal?: AbortSignal): AsyncIterable<Uint8Array>;
 }
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export 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

@@ -82,29 +82,29 @@ export class EchoerClientImpl {
         this.EchoBidiStream = this.EchoBidiStream.bind(this);
         this.RpcStream = this.RpcStream.bind(this);
     }
-    Echo(request) {
+    Echo(request, abortSignal) {
         const data = EchoMsg.encode(request).finish();
-        const promise = this.rpc.request(this.service, 'Echo', data);
+        const promise = this.rpc.request(this.service, 'Echo', data, abortSignal || undefined);
         return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
     }
-    EchoServerStream(request) {
+    EchoServerStream(request, abortSignal) {
         const data = EchoMsg.encode(request).finish();
-        const result = this.rpc.serverStreamingRequest(this.service, 'EchoServerStream', data);
+        const result = this.rpc.serverStreamingRequest(this.service, 'EchoServerStream', data, abortSignal || undefined);
         return EchoMsg.decodeTransform(result);
     }
-    EchoClientStream(request) {
+    EchoClientStream(request, abortSignal) {
         const data = EchoMsg.encodeTransform(request);
-        const promise = this.rpc.clientStreamingRequest(this.service, 'EchoClientStream', data);
+        const promise = this.rpc.clientStreamingRequest(this.service, 'EchoClientStream', data, abortSignal || undefined);
         return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
     }
-    EchoBidiStream(request) {
+    EchoBidiStream(request, abortSignal) {
         const data = EchoMsg.encodeTransform(request);
-        const result = this.rpc.bidirectionalStreamingRequest(this.service, 'EchoBidiStream', data);
+        const result = this.rpc.bidirectionalStreamingRequest(this.service, 'EchoBidiStream', data, abortSignal || undefined);
         return EchoMsg.decodeTransform(result);
     }
-    RpcStream(request) {
+    RpcStream(request, abortSignal) {
         const data = RpcStreamPacket.encodeTransform(request);
-        const result = this.rpc.bidirectionalStreamingRequest(this.service, 'RpcStream', data);
+        const result = this.rpc.bidirectionalStreamingRequest(this.service, 'RpcStream', data, abortSignal || undefined);
         return RpcStreamPacket.decodeTransform(result);
     }
 }

package/dist/integration/integration.js

@@ -1,5 +1,5 @@
 import { WebSocketConn } from '../srpc/websocket.js';
-import { runClientTest, runRpcStreamTest } from '../echo/client-test.js';
+import { runClientTest, runRpcStreamTest, runAbortControllerTest, } from '../echo/client-test.js';
 import WebSocket from 'isomorphic-ws';
 async function runRPC() {
     const addr = 'ws://localhost:5000/demo';
@@ -7,16 +7,22 @@ async function runRPC() {
     const ws = new WebSocket(addr);
     const channel = new WebSocketConn(ws, 'outbound');
     const client = channel.buildClient();
-    console.log('Running client test via WebSocket..');
-    await runClientTest(client);
     console.log('Running RpcStream test via WebSocket..');
     await runRpcStreamTest(client);
+    console.log('Running client test via WebSocket..');
+    await runClientTest(client);
+    console.log('Running abort controller test via WebSocket..');
+    await runAbortControllerTest(client);
 }
+process.on('unhandledRejection', (ev) => {
+    console.error('Unhandled rejection', ev);
+    throw ev;
+});
 runRPC()
     .then(() => {
     process.exit(0);
 })
     .catch((err) => {
-    console.error(err);
+    console.error('runRPC threw error', err);
     process.exit(1);
 });

package/dist/rpcstream/rpcstream.js

@@ -81,11 +81,9 @@ export async function* handleRpcStream(packetStream, getter) {
     }
     // build the outgoing packet sink & the packet source
     const packetSink = pushable({ objectMode: true });
-    // handle the stream in the next event queue tick.
+    // start the handler
     const rpcStream = new RpcStream(packetSink, packetStream);
-    setTimeout(() => {
-        handler(rpcStream);
-    }, 1);
+    handler(rpcStream);
     // process packets
     for await (const packet of packetSink) {
         yield* [packet];

package/dist/srpc/client.d.ts

@@ -4,9 +4,9 @@ export declare class Client implements TsProtoRpc {
     private openStreamCtr;
     constructor(openStreamFn?: OpenStreamFunc);
     setOpenStreamFn(openStreamFn?: OpenStreamFunc): void;
-    request(service: string, method: string, data: Uint8Array): Promise<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>;
+    request(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): Promise<Uint8Array>;
+    clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>, abortSignal?: AbortSignal): Promise<Uint8Array>;
+    serverStreamingRequest(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): AsyncIterable<Uint8Array>;
+    bidirectionalStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>, abortSignal?: AbortSignal): AsyncIterable<Uint8Array>;
     private startRpc;
 }

package/dist/srpc/client.js

@@ -1,5 +1,6 @@
 import { pipe } from 'it-pipe';
 import { pushable } from 'it-pushable';
+import { ERR_RPC_ABORT } from './errors.js';
 import { ClientRPC } from './client-rpc.js';
 import { writeToPushable } from './pushable.js';
 import { decodePacketSource, encodePacketSource, parseLengthPrefixTransform, prependLengthPrefixTransform, } from './packet.js';
@@ -15,8 +16,8 @@ export class Client {
         this.openStreamCtr.set(openStreamFn || undefined);
     }
     // request starts a non-streaming request.
-    async request(service, method, data) {
-        const call = await this.startRpc(service, method, data);
+    async request(service, method, data, abortSignal) {
+        const call = await this.startRpc(service, method, data, abortSignal);
         for await (const data of call.rpcDataSource) {
             call.close();
             return data;
@@ -26,8 +27,8 @@ export class Client {
         throw err;
     }
     // clientStreamingRequest starts a client side streaming request.
-    async clientStreamingRequest(service, method, data) {
-        const call = await this.startRpc(service, method, null);
+    async clientStreamingRequest(service, method, data, abortSignal) {
+        const call = await this.startRpc(service, method, null, abortSignal);
         call.writeCallDataFromSource(data);
         for await (const data of call.rpcDataSource) {
             call.close();
@@ -38,9 +39,9 @@ export class Client {
         throw err;
     }
     // serverStreamingRequest starts a server-side streaming request.
-    serverStreamingRequest(service, method, data) {
+    serverStreamingRequest(service, method, data, abortSignal) {
         const serverData = pushable({ objectMode: true });
-        this.startRpc(service, method, data)
+        this.startRpc(service, method, data, abortSignal)
             .then(async (call) => {
             return writeToPushable(call.rpcDataSource, serverData);
         })
@@ -48,9 +49,9 @@ export class Client {
         return serverData;
     }
     // bidirectionalStreamingRequest starts a two-way streaming request.
-    bidirectionalStreamingRequest(service, method, data) {
+    bidirectionalStreamingRequest(service, method, data, abortSignal) {
         const serverData = pushable({ objectMode: true });
-        this.startRpc(service, method, null)
+        this.startRpc(service, method, null, abortSignal)
             .then(async (call) => {
             call.writeCallDataFromSource(data);
             try {
@@ -69,10 +70,16 @@ export class Client {
     // startRpc is a common utility function to begin a rpc call.
     // throws any error starting the rpc call
     // if data == null and data.length == 0, sends a separate data packet.
-    async startRpc(rpcService, rpcMethod, data) {
+    async startRpc(rpcService, rpcMethod, data, abortSignal) {
+        if (abortSignal?.aborted) {
+            throw new Error(ERR_RPC_ABORT);
+        }
         const openStreamFn = await this.openStreamCtr.wait();
         const conn = await openStreamFn();
         const call = new ClientRPC(rpcService, rpcMethod);
+        abortSignal?.addEventListener('abort', () => {
+            call.close(new Error(ERR_RPC_ABORT));
+        });
         pipe(conn, parseLengthPrefixTransform(), combineUint8ArrayListTransform(), decodePacketSource, call, encodePacketSource, prependLengthPrefixTransform(), conn);
         await call.writeCallStart(data || undefined);
         return call;

package/dist/srpc/common-rpc.js

@@ -39,9 +39,9 @@ export class CommonRPC {
     async writeCallDataFromSource(dataSource) {
         try {
             for await (const data of dataSource) {
-                this.writeCallData(data);
+                await this.writeCallData(data);
             }
-            this.writeCallData(undefined, true);
+            await this.writeCallData(undefined, true);
         }
         catch (err) {
             this.close(err);
@@ -117,7 +117,8 @@ export class CommonRPC {
         }
         finally {
             this._rpcDataSource.end(err);
-            this._source.end(err);
+            // note: don't pass error to _source here.
+            this._source.end();
         }
     }
     // _createSink returns a value for the sink field.

package/dist/srpc/errors.d.ts

@@ -0,0 +1,2 @@
+export declare const ERR_RPC_ABORT = "ERR_RPC_ABORT";
+export declare function isAbortError(err: unknown): boolean;

package/dist/srpc/errors.js

@@ -0,0 +1,10 @@
+// ERR_RPC_ABORT is returned if the RPC was aborted.
+export const ERR_RPC_ABORT = 'ERR_RPC_ABORT';
+// isAbortError checks if the error object is ERR_RPC_ABORT.
+export function isAbortError(err) {
+    if (typeof err !== 'object') {
+        return false;
+    }
+    const message = err.message;
+    return message === ERR_RPC_ABORT;
+}

package/dist/srpc/index.d.ts

@@ -1,4 +1,5 @@
 export type { PacketHandler, Stream, OpenStreamFunc } from './stream.js';
+export { ERR_RPC_ABORT, isAbortError } from './errors.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { Conn, ConnParams } from './conn.js';

package/dist/srpc/index.js

@@ -1,3 +1,4 @@
+export { ERR_RPC_ABORT, isAbortError } from './errors.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { Conn } from './conn.js';

package/dist/srpc/server-rpc.js

@@ -33,11 +33,14 @@ export class ServerRPC extends CommonRPC {
         return super.handleCallData(packet);
     }
     // invokeRPC starts invoking the RPC handler.
-    invokeRPC(invokeFn) {
+    async invokeRPC(invokeFn) {
         const dataSink = this._createDataSink();
-        invokeFn(this.rpcDataSource, dataSink).catch((err) => {
+        try {
+            await invokeFn(this.rpcDataSource, dataSink);
+        }
+        catch (err) {
             this.close(err);
-        });
+        }
     }
     // _createDataSink creates a sink for outgoing data packets.
     _createDataSink() {

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

@@ -1,6 +1,6 @@
 export interface TsProtoRpc {
-    request(service: string, method: string, data: Uint8Array): Promise<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>;
+    request(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): Promise<Uint8Array>;
+    clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>, abortSignal?: AbortSignal): Promise<Uint8Array>;
+    serverStreamingRequest(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): AsyncIterable<Uint8Array>;
+    bidirectionalStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>, abortSignal?: AbortSignal): AsyncIterable<Uint8Array>;
 }

package/e2e/mock/mock.pb.ts

@@ -96,7 +96,7 @@ export const MockMsg = {
 /** Mock service mocks some RPCs for the e2e tests. */
 export interface Mock {
   /** MockRequest runs a mock unary request. */
-  MockRequest(request: MockMsg): Promise<MockMsg>
+  MockRequest(request: MockMsg, abortSignal?: AbortSignal): Promise<MockMsg>
 }
 
 export class MockClientImpl implements Mock {
@@ -107,9 +107,14 @@ export class MockClientImpl implements Mock {
     this.rpc = rpc
     this.MockRequest = this.MockRequest.bind(this)
   }
-  MockRequest(request: MockMsg): Promise<MockMsg> {
+  MockRequest(request: MockMsg, abortSignal?: AbortSignal): Promise<MockMsg> {
     const data = MockMsg.encode(request).finish()
-    const promise = this.rpc.request(this.service, 'MockRequest', data)
+    const promise = this.rpc.request(
+      this.service,
+      'MockRequest',
+      data,
+      abortSignal || undefined
+    )
     return promise.then((data) => MockMsg.decode(new _m0.Reader(data)))
   }
 }
@@ -136,7 +141,8 @@ interface Rpc {
   request(
     service: string,
     method: string,
-    data: Uint8Array
+    data: Uint8Array,
+    abortSignal?: AbortSignal
   ): Promise<Uint8Array>
 }
 

package/e2e/mock/mock_srpc.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-srpc. DO NOT EDIT.
-// protoc-gen-srpc version: v0.15.1
+// protoc-gen-srpc version: v0.15.4
 // source: github.com/aperturerobotics/starpc/e2e/mock/mock.proto
 
 package e2e_mock

package/echo/client-test.ts

@@ -1,4 +1,4 @@
-import { Client } from '../srpc/index.js'
+import { Client, ERR_RPC_ABORT } from '../srpc/index.js'
 import { EchoerClientImpl, EchoMsg } from './echo.pb.js'
 import { pushable } from 'it-pushable'
 import { buildRpcStreamOpenStream } from '../rpcstream/rpcstream.js'
@@ -30,6 +30,34 @@ export async function runClientTest(client: Client) {
   }
 }
 
+// runAbortControllerTest tests aborting a RPC call.
+export async function runAbortControllerTest(client: Client) {
+  const demoServiceClient = new EchoerClientImpl(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)
+    }
+  }
+  if (!errorReturned) {
+    throw new Error('expected aborted rpc to throw error')
+  }
+}
+
 // runRpcStreamTest tests a RPCStream.
 export async function runRpcStreamTest(client: Client) {
   console.log('Calling RpcStream to open a RPC stream client...')

package/echo/echo.pb.ts

@@ -97,16 +97,26 @@ export const EchoMsg = {
 /** Echoer service returns the given message. */
 export interface Echoer {
   /** Echo returns the given message. */
-  Echo(request: EchoMsg): Promise<EchoMsg>
+  Echo(request: EchoMsg, abortSignal?: AbortSignal): Promise<EchoMsg>
   /** EchoServerStream is an example of a server -> client one-way stream. */
-  EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>
+  EchoServerStream(
+    request: EchoMsg,
+    abortSignal?: AbortSignal
+  ): AsyncIterable<EchoMsg>
   /** EchoClientStream is an example of client->server one-way stream. */
-  EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>
+  EchoClientStream(
+    request: AsyncIterable<EchoMsg>,
+    abortSignal?: AbortSignal
+  ): Promise<EchoMsg>
   /** EchoBidiStream is an example of a two-way stream. */
-  EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>
+  EchoBidiStream(
+    request: AsyncIterable<EchoMsg>,
+    abortSignal?: AbortSignal
+  ): AsyncIterable<EchoMsg>
   /** RpcStream opens a nested rpc call stream. */
   RpcStream(
-    request: AsyncIterable<RpcStreamPacket>
+    request: AsyncIterable<RpcStreamPacket>,
+    abortSignal?: AbortSignal
   ): AsyncIterable<RpcStreamPacket>
 }
 
@@ -122,50 +132,69 @@ export class EchoerClientImpl implements Echoer {
     this.EchoBidiStream = this.EchoBidiStream.bind(this)
     this.RpcStream = this.RpcStream.bind(this)
   }
-  Echo(request: EchoMsg): Promise<EchoMsg> {
+  Echo(request: EchoMsg, abortSignal?: AbortSignal): Promise<EchoMsg> {
     const data = EchoMsg.encode(request).finish()
-    const promise = this.rpc.request(this.service, 'Echo', data)
+    const promise = this.rpc.request(
+      this.service,
+      'Echo',
+      data,
+      abortSignal || undefined
+    )
     return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
   }
 
-  EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg> {
+  EchoServerStream(
+    request: EchoMsg,
+    abortSignal?: AbortSignal
+  ): AsyncIterable<EchoMsg> {
     const data = EchoMsg.encode(request).finish()
     const result = this.rpc.serverStreamingRequest(
       this.service,
       'EchoServerStream',
-      data
+      data,
+      abortSignal || undefined
     )
     return EchoMsg.decodeTransform(result)
   }
 
-  EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg> {
+  EchoClientStream(
+    request: AsyncIterable<EchoMsg>,
+    abortSignal?: AbortSignal
+  ): Promise<EchoMsg> {
     const data = EchoMsg.encodeTransform(request)
     const promise = this.rpc.clientStreamingRequest(
       this.service,
       'EchoClientStream',
-      data
+      data,
+      abortSignal || undefined
     )
     return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
   }
 
-  EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg> {
+  EchoBidiStream(
+    request: AsyncIterable<EchoMsg>,
+    abortSignal?: AbortSignal
+  ): AsyncIterable<EchoMsg> {
     const data = EchoMsg.encodeTransform(request)
     const result = this.rpc.bidirectionalStreamingRequest(
       this.service,
       'EchoBidiStream',
-      data
+      data,
+      abortSignal || undefined
     )
     return EchoMsg.decodeTransform(result)
   }
 
   RpcStream(
-    request: AsyncIterable<RpcStreamPacket>
+    request: AsyncIterable<RpcStreamPacket>,
+    abortSignal?: AbortSignal
   ): AsyncIterable<RpcStreamPacket> {
     const data = RpcStreamPacket.encodeTransform(request)
     const result = this.rpc.bidirectionalStreamingRequest(
       this.service,
       'RpcStream',
-      data
+      data,
+      abortSignal || undefined
     )
     return RpcStreamPacket.decodeTransform(result)
   }
@@ -229,22 +258,26 @@ interface Rpc {
   request(
     service: string,
     method: string,
-    data: Uint8Array
+    data: Uint8Array,
+    abortSignal?: AbortSignal
   ): Promise<Uint8Array>
   clientStreamingRequest(
     service: string,
     method: string,
-    data: AsyncIterable<Uint8Array>
+    data: AsyncIterable<Uint8Array>,
+    abortSignal?: AbortSignal
   ): Promise<Uint8Array>
   serverStreamingRequest(
     service: string,
     method: string,
-    data: Uint8Array
+    data: Uint8Array,
+    abortSignal?: AbortSignal
   ): AsyncIterable<Uint8Array>
   bidirectionalStreamingRequest(
     service: string,
     method: string,
-    data: AsyncIterable<Uint8Array>
+    data: AsyncIterable<Uint8Array>,
+    abortSignal?: AbortSignal
   ): AsyncIterable<Uint8Array>
 }
 

package/echo/echo_srpc.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-srpc. DO NOT EDIT.
-// protoc-gen-srpc version: v0.15.1
+// protoc-gen-srpc version: v0.15.4
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 package echo

package/go.mod

@@ -5,12 +5,12 @@ go 1.18
 require (
 	github.com/pkg/errors v0.9.1
 	google.golang.org/protobuf v1.28.1
-	nhooyr.io/websocket v1.8.8-0.20210410000328-8dee580a7f74
+	nhooyr.io/websocket v1.8.8-0.20221213223501-14fb98eba64e
 )
 
 require (
-	github.com/aperturerobotics/util v0.0.0-20221202094321-2fde40039383
-	github.com/libp2p/go-libp2p v0.24.0-dev.0.20221202071826-2cc4de512664
+	github.com/aperturerobotics/util v0.0.0-20221205090205-f776a34d2d0d
+	github.com/libp2p/go-libp2p v0.24.1
 	github.com/libp2p/go-yamux/v4 v4.0.1-0.20220919134236-1c09f2ab3ec1
 	github.com/sirupsen/logrus v1.9.0
 )
@@ -19,23 +19,23 @@ require (
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/ipfs/go-cid v0.3.2 // indirect
-	github.com/klauspost/compress v1.15.10 // indirect
-	github.com/klauspost/cpuid/v2 v2.1.1 // indirect
+	github.com/klauspost/compress v1.15.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.1 // indirect
 	github.com/libp2p/go-buffer-pool v0.1.0 // indirect
 	github.com/libp2p/go-openssl v0.1.0 // indirect
 	github.com/mattn/go-pointer v0.0.1 // indirect
 	github.com/minio/sha256-simd v1.0.0 // indirect
 	github.com/mr-tron/base58 v1.2.0 // indirect
 	github.com/multiformats/go-base32 v0.1.0 // indirect
-	github.com/multiformats/go-base36 v0.1.1-0.20220823151017-f5af2eed4d9c // indirect
+	github.com/multiformats/go-base36 v0.2.0 // indirect
 	github.com/multiformats/go-multiaddr v0.8.0 // indirect
 	github.com/multiformats/go-multibase v0.1.2-0.20220823162309-7160a7347ed1 // indirect
 	github.com/multiformats/go-multicodec v0.7.1-0.20221017174837-a2baec7ca709 // indirect
 	github.com/multiformats/go-multihash v0.2.2-0.20221030163302-608669da49b6 // indirect
-	github.com/multiformats/go-varint v0.0.7-0.20220823162201-881f9a52d5d2 // indirect
+	github.com/multiformats/go-varint v0.0.7 // indirect
 	github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 // indirect
 	github.com/spaolacci/murmur3 v1.1.1-0.20190317074736-539464a789e9 // indirect
-	golang.org/x/crypto v0.2.1-0.20221109165004-21d60a152191 // indirect
-	golang.org/x/sys v0.2.0 // indirect
+	golang.org/x/crypto v0.3.0 // indirect
+	golang.org/x/sys v0.3.0 // indirect
 	lukechampine.com/blake3 v1.1.8-0.20220321170924-7afca5966e5e // indirect
 )

package/go.sum

@@ -1,5 +1,5 @@
-github.com/aperturerobotics/util v0.0.0-20221202094321-2fde40039383 h1:r0TEmQAFN1Ji+1iMqBW1ymiofevQaUb3uOQTje2wp3Q=
-github.com/aperturerobotics/util v0.0.0-20221202094321-2fde40039383/go.mod h1:up2AYcp62UgmFVTm7QhM4USXAKGv73gpb5dHraKmzxQ=
+github.com/aperturerobotics/util v0.0.0-20221205090205-f776a34d2d0d h1:nYXEY4LHTW7a7Vf+Lt+7icxoc02wIyLCa12xPbFuIxo=
+github.com/aperturerobotics/util v0.0.0-20221205090205-f776a34d2d0d/go.mod h1:up2AYcp62UgmFVTm7QhM4USXAKGv73gpb5dHraKmzxQ=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -42,18 +42,18 @@ github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/u
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/klauspost/compress v1.15.10 h1:Ai8UzuomSCDw90e1qNMtb15msBXsNpH6gzkkENQNcJo=
-github.com/klauspost/compress v1.15.10/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
+github.com/klauspost/compress v1.15.12 h1:YClS/PImqYbn+UILDnqxQCZ3RehC9N318SU3kElDUEM=
+github.com/klauspost/compress v1.15.12/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
 github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.1.1 h1:t0wUqjowdm8ezddV5k0tLWVklVuvLJpoHeb4WBdydm0=
-github.com/klauspost/cpuid/v2 v2.1.1/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/klauspost/cpuid/v2 v2.2.1 h1:U33DW0aiEj633gHYw3LoDNfkDiYnE5Q8M/TKJn2f2jI=
+github.com/klauspost/cpuid/v2 v2.2.1/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
 github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8=
 github.com/libp2p/go-buffer-pool v0.1.0/go.mod h1:N+vh8gMqimBzdKkSMVuydVDq+UV5QTWy5HSiZacSbPg=
-github.com/libp2p/go-libp2p v0.24.0-dev.0.20221202071826-2cc4de512664 h1:pv+MuIVoXKlPfxZ/dGjK+aDK3fFmfuo7ombAjrBN7z0=
-github.com/libp2p/go-libp2p v0.24.0-dev.0.20221202071826-2cc4de512664/go.mod h1:WVV1V9SPcZ0uV/sBB5X3zsKZW/EikukrgTp1ABOcqWk=
+github.com/libp2p/go-libp2p v0.24.1 h1:+lS4fqj7RF9egcPq9Yo3iqdRTcDMApzoBbQMhxtwOVw=
+github.com/libp2p/go-libp2p v0.24.1/go.mod h1:5LJqbrqFsUzWrq70JHCYqjATlX4ey8Klpct3OEe8hSI=
 github.com/libp2p/go-libp2p-testing v0.12.0 h1:EPvBb4kKMWO29qP4mZGyhVzUyR25dvfUIK5WDu6iPUA=
 github.com/libp2p/go-openssl v0.1.0 h1:LBkKEcUv6vtZIQLVTegAil8jbNpJErQ9AnT+bWV+Ooo=
 github.com/libp2p/go-openssl v0.1.0/go.mod h1:OiOxwPpL3n4xlenjx2h7AwSGaFSC/KZvf6gNdOBQMtc=
@@ -73,8 +73,8 @@ github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
 github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
 github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE=
 github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI=
-github.com/multiformats/go-base36 v0.1.1-0.20220823151017-f5af2eed4d9c h1:3eLctj5+2JpWf0E8PICebevkyD0KcZUhye8ggScrnEQ=
-github.com/multiformats/go-base36 v0.1.1-0.20220823151017-f5af2eed4d9c/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4=
+github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0=
+github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4=
 github.com/multiformats/go-multiaddr v0.8.0 h1:aqjksEcqK+iD/Foe1RRFsGZh8+XFiGo7FgUCZlpv3LU=
 github.com/multiformats/go-multiaddr v0.8.0/go.mod h1:Fs50eBDWvZu+l3/9S6xAE7ZYj6yhxlvaVZjakWN7xRs=
 github.com/multiformats/go-multibase v0.1.2-0.20220823162309-7160a7347ed1 h1:fts9VGSGzcENj3XnQ3iz9LGMAJAqT46fUGyaUDGFuxQ=
@@ -83,8 +83,8 @@ github.com/multiformats/go-multicodec v0.7.1-0.20221017174837-a2baec7ca709 h1:Xw
 github.com/multiformats/go-multicodec v0.7.1-0.20221017174837-a2baec7ca709/go.mod h1:GUC8upxSBE4oG+q3kWZRw/+6yC1BqO550bjhWsJbZlw=
 github.com/multiformats/go-multihash v0.2.2-0.20221030163302-608669da49b6 h1:qLF997Rz0X1WvdcZ2r5CUkLZ2rvdiXwG1JRSrJZEAuE=
 github.com/multiformats/go-multihash v0.2.2-0.20221030163302-608669da49b6/go.mod h1:kaHxr8TfO1cxIR/tYxgZ7e59HraJq8arEQQR8E/YNvI=
-github.com/multiformats/go-varint v0.0.7-0.20220823162201-881f9a52d5d2 h1:zsa4CR/QUzyyNdyaotjJrqFzKbzCsWzhQWcUSamGWr8=
-github.com/multiformats/go-varint v0.0.7-0.20220823162201-881f9a52d5d2/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU=
+github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8=
+github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -99,7 +99,7 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
 github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
 github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
 github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
@@ -109,8 +109,8 @@ github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9dec
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.2.1-0.20221109165004-21d60a152191 h1:mPxyLskqfKMEHYEIa1kKmcNC8ZSiJLYbMaXyUpW+ooY=
-golang.org/x/crypto v0.2.1-0.20221109165004-21d60a152191/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
+golang.org/x/crypto v0.3.0 h1:a06MkbcxBrEFc0w0QIZWXrH/9cCX6KJyWbBOIwAn+7A=
+golang.org/x/crypto v0.3.0/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@@ -126,8 +126,8 @@ golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0 h1:ljd4t30dBnAvMZaQCevtY0xLLD0A+bRZXbgLMLU1F/A=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
+golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
@@ -152,5 +152,5 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 lukechampine.com/blake3 v1.1.8-0.20220321170924-7afca5966e5e h1:YeQnmA0g9M+7uVBjUXNUpVQRfWrvTu4I5u+DjFudflw=
 lukechampine.com/blake3 v1.1.8-0.20220321170924-7afca5966e5e/go.mod h1:tkKEOtDkNtklkXtLNEOGNq5tcV90tJiA1vAA12R78LA=
-nhooyr.io/websocket v1.8.8-0.20210410000328-8dee580a7f74 h1:V2XOYY4rGPHLTGQD4TiOMOfVwNd0zAuEPofzzEqiFWk=
-nhooyr.io/websocket v1.8.8-0.20210410000328-8dee580a7f74/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=
+nhooyr.io/websocket v1.8.8-0.20221213223501-14fb98eba64e h1:Sk+k5z84Elo/gfEvX1xQR83Yhd6ETPmVDJTXUd2BxR4=
+nhooyr.io/websocket v1.8.8-0.20221213223501-14fb98eba64e/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=

package/integration/integration.ts

@@ -1,5 +1,9 @@
 import { WebSocketConn } from '../srpc/websocket.js'
-import { runClientTest, runRpcStreamTest } from '../echo/client-test.js'
+import {
+  runClientTest,
+  runRpcStreamTest,
+  runAbortControllerTest,
+} from '../echo/client-test.js'
 import WebSocket from 'isomorphic-ws'
 
 async function runRPC() {
@@ -9,18 +13,26 @@ async function runRPC() {
   const channel = new WebSocketConn(ws, 'outbound')
   const client = channel.buildClient()
 
+  console.log('Running RpcStream test via WebSocket..')
+  await runRpcStreamTest(client)
+
   console.log('Running client test via WebSocket..')
   await runClientTest(client)
 
-  console.log('Running RpcStream test via WebSocket..')
-  await runRpcStreamTest(client)
+  console.log('Running abort controller test via WebSocket..')
+  await runAbortControllerTest(client)
 }
 
+process.on('unhandledRejection', (ev) => {
+  console.error('Unhandled rejection', ev)
+  throw ev
+})
+
 runRPC()
   .then(() => {
     process.exit(0)
   })
   .catch((err) => {
-    console.error(err)
+    console.error('runRPC threw error', err)
     process.exit(1)
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.15.3",
+  "version": "0.16.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -60,33 +60,33 @@
     "singleQuote": true
   },
   "devDependencies": {
-    "@aperturerobotics/ts-common": "^0.2.6",
-    "@typescript-eslint/eslint-plugin": "^5.45.0",
-    "@typescript-eslint/parser": "^5.45.0",
+    "@aperturerobotics/ts-common": "^0.3.1",
+    "@typescript-eslint/eslint-plugin": "^5.46.1",
+    "@typescript-eslint/parser": "^5.46.1",
     "bufferutil": "^4.0.7",
     "depcheck": "^1.4.3",
-    "esbuild": "^0.15.16",
-    "eslint": "^8.28.0",
+    "esbuild": "^0.16.7",
+    "eslint": "^8.29.0",
     "eslint-config-prettier": "^8.5.0",
-    "prettier": "^2.8.0",
+    "prettier": "^2.8.1",
     "rimraf": "^3.0.2",
-    "ts-proto": "^1.135.0",
-    "typescript": "^4.9.3",
+    "ts-proto": "^1.136.0",
+    "typescript": "^4.9.4",
     "utf-8-validate": "^5.0.10"
   },
   "dependencies": {
     "@chainsafe/libp2p-yamux": "^3.0.3",
-    "@libp2p/interface-connection": "^3.0.3",
-    "@libp2p/interface-stream-muxer": "^3.0.1",
+    "@libp2p/interface-connection": "^3.0.4",
+    "@libp2p/interface-stream-muxer": "^3.0.2",
     "event-iterator": "^2.0.0",
     "is-promise": "^4.0.0",
     "isomorphic-ws": "^5.0.0",
     "it-first": "^2.0.0",
     "it-length-prefixed": "^8.0.3",
-    "it-pipe": "^2.0.4",
+    "it-pipe": "^2.0.5",
     "it-pushable": "^3.1.0",
     "it-stream-types": "^1.0.4",
-    "it-ws": "^5.0.3",
+    "it-ws": "^5.0.6",
     "long": "^5.2.1",
     "patch-package": "^6.5.0",
     "protobufjs": "^7.1.2",

package/srpc/client.ts

@@ -1,6 +1,7 @@
 import { pipe } from 'it-pipe'
 import { pushable, Pushable } from 'it-pushable'
 
+import { ERR_RPC_ABORT } from './errors.js'
 import type { TsProtoRpc } from './ts-proto-rpc.js'
 import type { OpenStreamFunc } from './stream.js'
 import { ClientRPC } from './client-rpc.js'
@@ -32,9 +33,10 @@ export class Client implements TsProtoRpc {
   public async request(
     service: string,
     method: string,
-    data: Uint8Array
+    data: Uint8Array,
+    abortSignal?: AbortSignal
   ): Promise<Uint8Array> {
-    const call = await this.startRpc(service, method, data)
+    const call = await this.startRpc(service, method, data, abortSignal)
     for await (const data of call.rpcDataSource) {
       call.close()
       return data
@@ -48,9 +50,10 @@ export class Client implements TsProtoRpc {
   public async clientStreamingRequest(
     service: string,
     method: string,
-    data: AsyncIterable<Uint8Array>
+    data: AsyncIterable<Uint8Array>,
+    abortSignal?: AbortSignal
   ): Promise<Uint8Array> {
-    const call = await this.startRpc(service, method, null)
+    const call = await this.startRpc(service, method, null, abortSignal)
     call.writeCallDataFromSource(data)
     for await (const data of call.rpcDataSource) {
       call.close()
@@ -65,10 +68,11 @@ export class Client implements TsProtoRpc {
   public serverStreamingRequest(
     service: string,
     method: string,
-    data: Uint8Array
+    data: Uint8Array,
+    abortSignal?: AbortSignal
   ): AsyncIterable<Uint8Array> {
     const serverData: Pushable<Uint8Array> = pushable({ objectMode: true })
-    this.startRpc(service, method, data)
+    this.startRpc(service, method, data, abortSignal)
       .then(async (call) => {
         return writeToPushable(call.rpcDataSource, serverData)
       })
@@ -80,10 +84,11 @@ export class Client implements TsProtoRpc {
   public bidirectionalStreamingRequest(
     service: string,
     method: string,
-    data: AsyncIterable<Uint8Array>
+    data: AsyncIterable<Uint8Array>,
+    abortSignal?: AbortSignal
   ): AsyncIterable<Uint8Array> {
     const serverData: Pushable<Uint8Array> = pushable({ objectMode: true })
-    this.startRpc(service, method, null)
+    this.startRpc(service, method, null, abortSignal)
       .then(async (call) => {
         call.writeCallDataFromSource(data)
         try {
@@ -105,11 +110,18 @@ export class Client implements TsProtoRpc {
   private async startRpc(
     rpcService: string,
     rpcMethod: string,
-    data: Uint8Array | null
+    data: Uint8Array | null,
+    abortSignal?: AbortSignal
   ): Promise<ClientRPC> {
+    if (abortSignal?.aborted) {
+      throw new Error(ERR_RPC_ABORT)
+    }
     const openStreamFn = await this.openStreamCtr.wait()
     const conn = await openStreamFn()
     const call = new ClientRPC(rpcService, rpcMethod)
+    abortSignal?.addEventListener('abort', () => {
+      call.close(new Error(ERR_RPC_ABORT))
+    })
     pipe(
       conn,
       parseLengthPrefixTransform(),

package/srpc/common-rpc.ts

@@ -74,9 +74,9 @@ export class CommonRPC {
   public async writeCallDataFromSource(dataSource: AsyncIterable<Uint8Array>) {
     try {
       for await (const data of dataSource) {
-        this.writeCallData(data)
+        await this.writeCallData(data)
       }
-      this.writeCallData(undefined, true)
+      await this.writeCallData(undefined, true)
     } catch (err) {
       this.close(err as Error)
     }
@@ -160,7 +160,8 @@ export class CommonRPC {
       await this.writeCallCancel()
     } finally {
       this._rpcDataSource.end(err)
-      this._source.end(err)
+      // note: don't pass error to _source here.
+      this._source.end()
     }
   }
 

package/srpc/errors.ts

@@ -0,0 +1,11 @@
+// ERR_RPC_ABORT is returned if the RPC was aborted.
+export const ERR_RPC_ABORT = 'ERR_RPC_ABORT'
+
+// isAbortError checks if the error object is ERR_RPC_ABORT.
+export function isAbortError(err: unknown): boolean {
+  if (typeof err !== 'object') {
+    return false
+  }
+  const message = (err as Error).message
+  return message === ERR_RPC_ABORT
+}

package/srpc/index.ts

@@ -1,4 +1,5 @@
 export type { PacketHandler, Stream, OpenStreamFunc } from './stream.js'
+export { ERR_RPC_ABORT, isAbortError } from './errors.js'
 export { Client } from './client.js'
 export { Server } from './server.js'
 export { Conn, ConnParams } from './conn.js'

package/srpc/server-rpc.ts

@@ -45,11 +45,13 @@ export class ServerRPC extends CommonRPC {
   }
 
   // invokeRPC starts invoking the RPC handler.
-  private invokeRPC(invokeFn: InvokeFn) {
+  private async invokeRPC(invokeFn: InvokeFn) {
     const dataSink = this._createDataSink()
-    invokeFn(this.rpcDataSource, dataSink).catch((err) => {
-      this.close(err)
-    })
+    try {
+      await invokeFn(this.rpcDataSource, dataSink)
+    } catch (err) {
+      this.close(err as Error)
+    }
   }
 
   // _createDataSink creates a sink for outgoing data packets.

package/srpc/ts-proto-rpc.ts

@@ -4,24 +4,28 @@ export interface TsProtoRpc {
   request(
     service: string,
     method: string,
-    data: Uint8Array
+    data: Uint8Array,
+    abortSignal?: AbortSignal
   ): Promise<Uint8Array>
   // clientStreamingRequest fires a one-way client->server streaming request.
   clientStreamingRequest(
     service: string,
     method: string,
-    data: AsyncIterable<Uint8Array>
+    data: AsyncIterable<Uint8Array>,
+    abortSignal?: AbortSignal
   ): Promise<Uint8Array>
   // serverStreamingRequest fires a one-way server->client streaming request.
   serverStreamingRequest(
     service: string,
     method: string,
-    data: Uint8Array
+    data: Uint8Array,
+    abortSignal?: AbortSignal
   ): AsyncIterable<Uint8Array>
   // bidirectionalStreamingRequest implements a two-way streaming request.
   bidirectionalStreamingRequest(
     service: string,
     method: string,
-    data: AsyncIterable<Uint8Array>
+    data: AsyncIterable<Uint8Array>,
+    abortSignal?: AbortSignal
   ): AsyncIterable<Uint8Array>
 }