starpc 0.49.20 → 0.51.0

package/srpc/server-rpc.go

@@ -98,7 +98,7 @@ func (r *ServerRPC) HandleCallStart(pkt *CallStart) error {
 // invokeRPC invokes the RPC after CallStart is received.
 func (r *ServerRPC) invokeRPC(serviceID, methodID string) {
 	// on the server side, the writer is closed by invokeRPC.
-	strm := NewMsgStream(withServerInvocation(r.ctx, r), r, r.cancelContext)
+	strm := NewMsgStream(r.ctx, r, r.cancelContext)
 	ok, err := r.invoker.InvokeMethod(serviceID, methodID, strm)
 	if err == nil && !ok {
 		err = ErrUnimplemented

package/srpc/server-rpc.ts

@@ -3,7 +3,6 @@ import type { Sink, Source } from 'it-stream-types'
 import type { CallData, CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
 import { InvokeFn } from './handler.js'
-import { ServerInvocation } from './server-invocation.js'
 import { LookupMethod } from './mux.js'
 
 // ServerRPC is an ongoing RPC from the server side.
@@ -47,12 +46,8 @@ export class ServerRPC extends CommonRPC {
   // invokeRPC starts invoking the RPC handler.
   private async invokeRPC(invokeFn: InvokeFn) {
     const dataSink = this._createDataSink()
-    const invocation = new ServerInvocation(
-      this.invocationSignal,
-      (ownerSignal) => this.waitTerminal(ownerSignal),
-    )
     try {
-      await invokeFn(this.rpcDataSource, dataSink, invocation)
+      await invokeFn(this.rpcDataSource, dataSink, this.invocationSignal)
     } catch (err) {
       this.close(err as Error)
     }

package/srpc/server.test.ts

@@ -15,13 +15,14 @@ import {
   EchoerDefinition,
   EchoerServer,
   EchoerServiceName,
+  EchoMsg,
   runClientTest,
 } from '../echo/index.js'
 import {
   runAbortControllerTest,
   runRpcStreamTest,
 } from '../echo/client-test.js'
-
+import type { EchoMsg as EchoMsgType } from '../echo/echo.pb.js'
 describe('srpc server', () => {
   let client: Client
 
@@ -77,6 +78,37 @@ describe('srpc server', () => {
   it('should pass rpc stream tests', async () => {
     await runRpcStreamTest(client)
   })
+  it('passes the exact invocation signal after async request decode', async () => {
+    const controller = new AbortController()
+    let observedSignal: AbortSignal | undefined
+    const handler = createHandler(EchoerDefinition, {
+      Echo: async (request: EchoMsgType, signal?: AbortSignal) => {
+        observedSignal = signal
+        return request
+      },
+    })
+    const invokeFn = await handler.lookupMethod(EchoerServiceName, 'Echo')
+    if (!invokeFn) {
+      throw new Error('Echo method was not found')
+    }
+    const request = EchoMsg.create({ body: 'signal identity' })
+    const drained = Promise.withResolvers<void>()
+    await invokeFn(
+      (async function* () {
+        await Promise.resolve()
+        yield EchoMsg.toBinary(request)
+      })(),
+      async (source) => {
+        for await (const _data of source) {
+          // Drain the encoded response so the invocation pipeline completes.
+        }
+        drained.resolve()
+      },
+      controller.signal,
+    )
+    await drained.promise
+    expect(observedSignal).toBe(controller.signal)
+  })
 
   it('keeps detached server-streaming responses open after request source completes', async () => {
     const mux = createMux()
@@ -249,6 +281,22 @@ describe('srpc server', () => {
     )
   })
 
+  it('settles a late abort after the call has already closed', async () => {
+    const controller = new AbortController()
+    vi.spyOn(controller.signal, 'removeEventListener').mockImplementation(
+      () => undefined,
+    )
+
+    await client.request(
+      EchoerServiceName,
+      'Echo',
+      new TextEncoder().encode('late abort'),
+      controller.signal,
+    )
+    controller.abort()
+    await Promise.resolve()
+  })
+
   it('tears down passive channel close state', async () => {
     const { port1, port2 } = new MessageChannel()
     const opts: ChannelStreamOpts = { idleTimeoutMs: 1000, keepAliveMs: 1000 }

package/srpc/stream-pipe.go

@@ -85,4 +85,4 @@ func (p *pipeStream) closeRemote() {
 }
 
 // _ is a type assertion
-var _ Stream = ((*pipeStream)(nil))
+var _ Stream = (*pipeStream)(nil)

package/srpc/stream-rwc.go

@@ -82,4 +82,4 @@ func (s *StreamRwc) Write(p []byte) (n int, err error) {
 }
 
 // _ is a type assertion
-var _ io.ReadWriteCloser = ((*StreamRwc)(nil))
+var _ io.ReadWriteCloser = (*StreamRwc)(nil)

package/srpc/stream-yamux.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"time"
 
-	yamux "github.com/libp2p/go-yamux/v4"
+	yamux "github.com/libp2p/go-yamux/v5"
 )
 
 // yamuxStream wraps a yamux.Stream to implement MuxedStream.

package/srpc/stream.go

@@ -23,10 +23,6 @@ type Stream interface {
 	Close() error
 }
 
-type receiptTerminalStream interface {
-	receiptTerminalKind() (TerminalKind, bool)
-}
-
 // StreamRecv is a stream that can receive typed messages.
 //
 // T is the response type.
@@ -73,14 +69,6 @@ func (s *streamWithClose) Close() error {
 	return err2
 }
 
-func (s *streamWithClose) receiptTerminalKind() (TerminalKind, bool) {
-	receipt, ok := s.Stream.(receiptTerminalStream)
-	if !ok {
-		return 0, false
-	}
-	return receipt.receiptTerminalKind()
-}
-
 // streamWithContext is a Stream with a wrapped Context function.
 type streamWithContext struct {
 	Stream
@@ -97,14 +85,6 @@ func (s *streamWithContext) Context() context.Context {
 	return s.ctx
 }
 
-func (s *streamWithContext) receiptTerminalKind() (TerminalKind, bool) {
-	receipt, ok := s.Stream.(receiptTerminalStream)
-	if !ok {
-		return 0, false
-	}
-	return receipt.receiptTerminalKind()
-}
-
 // _ is a type assertion
 var (
 	_ Stream = (*streamWithClose)(nil)

package/srpc/websocket.go

@@ -4,7 +4,7 @@ import (
 	"context"
 
 	"github.com/aperturerobotics/go-websocket"
-	"github.com/libp2p/go-yamux/v4"
+	"github.com/libp2p/go-yamux/v5"
 )
 
 // NewWebSocketConn wraps a websocket into a MuxedConn.

package/dist/srpc/call-receipt.d.ts

@@ -1,17 +0,0 @@
-import { ClientRPC } from './client-rpc.js';
-export interface ReceiptRpc {
-    requestWithReceipt(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): Promise<HeldCall>;
-}
-export interface HeldCall {
-    readonly response: Uint8Array;
-    readonly receipt: CallReceipt;
-}
-export declare class CallReceipt {
-    #private;
-    constructor(call: ClientRPC, iterator: AsyncIterator<Uint8Array>);
-    get done(): Promise<void>;
-    get settled(): boolean;
-    commit(): Promise<void>;
-    abort(reason?: Error): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
-}

package/dist/srpc/call-receipt.js

@@ -1,105 +0,0 @@
-/// <reference lib="es2024.promise" />
-import { ERR_RPC_ABORT } from './errors.js';
-// CallReceipt holds a unary call until it is committed or aborted.
-export class CallReceipt {
-    #call;
-    #iterator;
-    #terminalPromise;
-    #terminal;
-    #done;
-    #requestCommitted = false;
-    #resolveDone;
-    #rejectDone;
-    constructor(call, iterator) {
-        this.#call = call;
-        this.#iterator = iterator;
-        const { promise, resolve, reject } = Promise.withResolvers();
-        this.#done = promise;
-        this.#resolveDone = resolve;
-        this.#rejectDone = reject;
-        this.#done.catch(() => undefined);
-        this.#terminalPromise = this.#observeTerminal();
-        this.#terminalPromise.catch(() => undefined);
-    }
-    async #observeTerminal() {
-        try {
-            const result = await this.#iterator.next();
-            if (!result.done) {
-                throw new Error('unexpected trailing response data');
-            }
-            const terminal = this.#call.getTerminalKind();
-            if (terminal !== 'committed' ||
-                !this.#requestCommitted ||
-                this.#terminal !== 'committed') {
-                throw new Error('receipt closed before commit');
-            }
-            return result;
-        }
-        catch (err) {
-            this.#rejectDone(err);
-            const error = err instanceof Error ? err : new Error('receipt terminal failed');
-            try {
-                await this.#call.close(error);
-            }
-            catch {
-                // The primary terminal error is already recorded on the receipt.
-            }
-            throw err;
-        }
-    }
-    // done resolves after committed close and rejects on terminal failure.
-    get done() {
-        return this.#done;
-    }
-    // settled reports whether a terminal transition has been claimed.
-    get settled() {
-        return this.#terminal !== undefined;
-    }
-    // commit sends request completion and waits for server finalization.
-    async commit() {
-        if (this.#terminal === 'aborted') {
-            throw new Error(ERR_RPC_ABORT);
-        }
-        if (this.#terminal === 'committed') {
-            return this.#done;
-        }
-        this.#terminal = 'committed';
-        this.#requestCommitted = true;
-        try {
-            await this.#call.writeCallData(undefined, true);
-            await this.#terminalPromise;
-            await this.#call.close();
-            this.#resolveDone();
-        }
-        catch (err) {
-            await this.#call.close(err instanceof Error ? err : new Error('receipt commit failed'));
-            this.#rejectDone(err);
-            throw err;
-        }
-    }
-    // abort sends request cancellation and never rejects.
-    async abort(reason) {
-        if (this.#terminal !== undefined) {
-            return;
-        }
-        this.#terminal = 'aborted';
-        let terminalError = reason;
-        try {
-            await this.#call.writeCallCancel(true);
-        }
-        catch (err) {
-            terminalError ??= err;
-        }
-        try {
-            await this.#call.close();
-        }
-        catch (err) {
-            terminalError ??= err;
-        }
-        this.#rejectDone(terminalError ?? new Error(ERR_RPC_ABORT));
-    }
-    // asyncDispose aborts a receipt that has not reached a terminal.
-    async [Symbol.asyncDispose]() {
-        await this.abort();
-    }
-}

package/dist/srpc/call-receipt.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/srpc/call-receipt.test.js

@@ -1,374 +0,0 @@
-/// <reference lib="es2024.promise" />
-import { describe, expect, it } from 'vitest';
-import { pushable } from 'it-pushable';
-import { EchoMsg } from '../echo/echo.pb.js';
-import { Client } from './client.js';
-import { ClientRPC } from './client-rpc.js';
-import { Server } from './server.js';
-import { CallReceipt } from './call-receipt.js';
-import { Packet } from './rpcproto.pb.js';
-import { ServerRPC } from './server-rpc.js';
-const response = new Uint8Array([1, 2, 3]);
-describe('generated service compatibility', () => {
-    it('accepts plain abort signals and terminal-capable handlers', async () => {
-        const server = {
-            Echo: async (request, invocation) => {
-                void invocation;
-                return request;
-            },
-        };
-        const request = EchoMsg.create({ body: 'compatibility' });
-        const signal = new AbortController().signal;
-        await expect(server.Echo(request, signal)).resolves.toEqual(request);
-    });
-});
-describe('held unary receipt', () => {
-    it('waits for a server completion acknowledgment', async () => {
-        const sent = [];
-        const terminal = Promise.withResolvers();
-        const client = new Client(async () => ({
-            source: responseSource(terminal.promise),
-            sink: async (source) => {
-                for await (const data of source) {
-                    const packet = Packet.fromBinary(data);
-                    sent.push(packet);
-                    if (packet.body?.case === 'callData' && packet.body.value.complete) {
-                        terminal.resolve();
-                    }
-                }
-            },
-        }));
-        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
-        const commit = held.receipt.commit();
-        expect(held.receipt.settled).toBe(true);
-        await expect(commit).resolves.toBeUndefined();
-        const terminalPackets = sent.filter((packet) => {
-            const body = packet.body;
-            return (body?.case === 'callCancel' ||
-                (body?.case === 'callData' && body.value.complete));
-        });
-        expect(terminalPackets).toHaveLength(1);
-        expect(terminalPackets[0]?.body?.case).toBe('callData');
-        await expect(held.receipt.done).resolves.toBeUndefined();
-    });
-    it('commits through a real TypeScript server', async () => {
-        const terminal = Promise.withResolvers();
-        const server = new Server(async () => {
-            return async (_source, dataSink, invocation) => {
-                await dataSink((async function* () {
-                    yield response;
-                    if (!invocation) {
-                        throw new Error('missing invocation');
-                    }
-                    terminal.resolve(await invocation.waitTerminal(new AbortController().signal));
-                })());
-            };
-        });
-        const client = new Client(async () => {
-            const clientToServer = pushable({ objectMode: true });
-            const serverToClient = pushable({ objectMode: true });
-            server.handlePacketStream({
-                source: clientToServer,
-                sink: async (source) => {
-                    for await (const packet of source) {
-                        serverToClient.push(packet);
-                    }
-                    serverToClient.end();
-                },
-            });
-            return {
-                source: serverToClient,
-                sink: async (source) => {
-                    for await (const packet of source) {
-                        clientToServer.push(packet);
-                    }
-                    clientToServer.end();
-                },
-            };
-        });
-        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
-        await expect(held.receipt.commit()).resolves.toBeUndefined();
-        await expect(terminal.promise).resolves.toBe('committed');
-    });
-    it('rejects commit after a bare remote close', async () => {
-        const call = new ClientRPC('test.Service', 'Unary');
-        const iterator = call.rpcDataSource[Symbol.asyncIterator]();
-        await call.handleCallData({
-            data: response,
-            dataIsZero: false,
-            complete: false,
-            error: '',
-        });
-        const first = await iterator.next();
-        expect(first.done).toBe(false);
-        const receipt = new CallReceipt(call, iterator);
-        await call.close();
-        await expect(receipt.commit()).rejects.toThrow();
-        await expect(receipt.done).rejects.toThrow('receipt closed before commit');
-    });
-    it('aborts a held receipt with one cancel packet', async () => {
-        const sent = [];
-        const terminal = Promise.withResolvers();
-        const cancelSeen = Promise.withResolvers();
-        const client = new Client(async () => ({
-            source: responseSource(terminal.promise),
-            sink: async (source) => {
-                for await (const data of source) {
-                    const packet = Packet.fromBinary(data);
-                    sent.push(packet);
-                    if (packet.body?.case === 'callCancel') {
-                        cancelSeen.resolve();
-                    }
-                }
-            },
-        }));
-        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
-        await held.receipt.abort();
-        await cancelSeen.promise;
-        const terminalPackets = sent.filter((packet) => packet.body?.case === 'callCancel');
-        expect(terminalPackets).toHaveLength(1);
-        await expect(held.receipt.done).rejects.toThrow();
-    });
-    it('allows exactly one concurrent commit or abort terminal', async () => {
-        const sent = [];
-        const terminal = Promise.withResolvers();
-        const client = new Client(async () => ({
-            source: responseSource(terminal.promise),
-            sink: async (source) => {
-                for await (const data of source) {
-                    const packet = Packet.fromBinary(data);
-                    sent.push(packet);
-                    if (packet.body?.case === 'callData' && packet.body.value.complete) {
-                        terminal.resolve();
-                    }
-                }
-            },
-        }));
-        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
-        const results = await Promise.allSettled([
-            held.receipt.commit(),
-            held.receipt.abort(),
-        ]);
-        const terminalPackets = sent.filter((packet) => {
-            const body = packet.body;
-            return (body?.case === 'callCancel' ||
-                (body?.case === 'callData' && body.value.complete));
-        });
-        expect(terminalPackets).toHaveLength(1);
-        expect(results).toHaveLength(2);
-    });
-    it('rejects a trailing response datum instead of committing', async () => {
-        const terminal = Promise.withResolvers();
-        const client = new Client(async () => ({
-            source: (async function* () {
-                yield Packet.toBinary({
-                    body: {
-                        case: 'callData',
-                        value: {
-                            data: response,
-                            dataIsZero: false,
-                            complete: false,
-                            error: '',
-                        },
-                    },
-                });
-                await terminal.promise;
-                yield Packet.toBinary({
-                    body: {
-                        case: 'callData',
-                        value: {
-                            data: new Uint8Array([9]),
-                            dataIsZero: false,
-                            complete: false,
-                            error: '',
-                        },
-                    },
-                });
-            })(),
-            sink: async (source) => {
-                for await (const data of source) {
-                    const packet = Packet.fromBinary(data);
-                    if (packet.body?.case === 'callData' && packet.body.value.complete) {
-                        terminal.resolve();
-                    }
-                }
-            },
-        }));
-        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
-        await expect(held.receipt.commit()).rejects.toThrow('unexpected trailing response data');
-    });
-    it('rejects done on a remote terminal error', async () => {
-        const client = new Client(async () => ({
-            source: (async function* () {
-                yield Packet.toBinary({
-                    body: {
-                        case: 'callData',
-                        value: {
-                            data: response,
-                            dataIsZero: false,
-                            complete: false,
-                            error: '',
-                        },
-                    },
-                });
-                yield Packet.toBinary({
-                    body: {
-                        case: 'callData',
-                        value: {
-                            data: new Uint8Array(),
-                            dataIsZero: false,
-                            complete: true,
-                            error: 'remote failure',
-                        },
-                    },
-                });
-            })(),
-            sink: async (source) => {
-                for await (const _data of source) {
-                    void _data;
-                }
-            },
-        }));
-        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
-        await expect(held.receipt.done).rejects.toThrow('remote failure');
-    });
-});
-describe('server invocation terminal', () => {
-    it.each([
-        ['explicit completion', 'committed'],
-        ['cancel', 'canceled'],
-        ['transport loss', 'transportLost'],
-        ['remote error packet', 'transportLost'],
-        ['bare close', 'closed'],
-        ['remote error packet with completion', 'transportLost'],
-    ])('%s is classified distinctly', async (_name, expected) => {
-        const captured = Promise.withResolvers();
-        const owner = new AbortController();
-        const observed = Promise.withResolvers();
-        const rpc = new ServerRPC(async () => {
-            return async (_source, _sink, invocation) => {
-                if (!invocation) {
-                    throw new Error('missing invocation');
-                }
-                captured.resolve(invocation);
-                observed.resolve(await invocation.waitTerminal(owner.signal));
-            };
-        });
-        await rpc.handleCallStart({
-            rpcService: 'test.Service',
-            rpcMethod: 'Unary',
-            data: new Uint8Array(),
-            dataIsZero: true,
-        });
-        const invocation = await captured.promise;
-        if (expected === 'committed') {
-            await rpc.handleCallData({ complete: true });
-        }
-        else if (expected === 'canceled') {
-            await rpc.handleCallCancel();
-        }
-        else if (expected === 'transportLost') {
-            if (_name === 'remote error packet' ||
-                _name === 'remote error packet with completion') {
-                await rpc.handleCallData({
-                    complete: _name === 'remote error packet with completion',
-                    error: 'remote failure',
-                });
-            }
-            else {
-                await rpc.close(new Error('transport loss'));
-            }
-        }
-        else {
-            await rpc.close();
-        }
-        await expect(observed.promise).resolves.toBe(expected);
-        owner.abort();
-        if (_name === 'remote error packet with completion') {
-            const rpcState = rpc;
-            if (!('remoteCompleted' in rpcState)) {
-                throw new Error('remote completion discriminator is missing');
-            }
-            expect(rpcState.remoteCompleted).toBe(false);
-        }
-        if (expected === 'closed' || expected === 'transportLost') {
-            expect(invocation.signal.aborted).toBe(true);
-        }
-    });
-    it.each(['transport loss', 'cancel'])('keeps completion after %s', async (followUp) => {
-        const captured = Promise.withResolvers();
-        const owner = new AbortController();
-        const rpc = new ServerRPC(async () => {
-            return async (_source, _sink, invocation) => {
-                if (!invocation) {
-                    throw new Error('missing invocation');
-                }
-                captured.resolve(invocation);
-                await invocation.waitTerminal(owner.signal);
-            };
-        });
-        await rpc.handleCallStart({
-            rpcService: 'test.Service',
-            rpcMethod: 'Unary',
-            data: new Uint8Array(),
-            dataIsZero: true,
-        });
-        const invocation = await captured.promise;
-        await rpc.handleCallData({ complete: true });
-        if (followUp === 'transport loss') {
-            await rpc.close(new Error('transport loss'));
-        }
-        else {
-            await rpc.handleCallCancel();
-        }
-        await expect(invocation.waitTerminal(owner.signal)).resolves.toBe('committed');
-        owner.abort();
-    });
-    it('returns abandoned only for owner cancellation without a remote terminal', async () => {
-        const captured = Promise.withResolvers();
-        const owner = new AbortController();
-        const rpc = new ServerRPC(async () => {
-            return async (_source, _sink, invocation) => {
-                if (!invocation) {
-                    throw new Error('missing invocation');
-                }
-                captured.resolve(invocation);
-                await invocation.waitTerminal(owner.signal);
-            };
-        });
-        await rpc.handleCallStart({
-            rpcService: 'test.Service',
-            rpcMethod: 'Unary',
-            data: new Uint8Array(),
-            dataIsZero: true,
-        });
-        const invocation = await captured.promise;
-        owner.abort();
-        await expect(invocation.waitTerminal(owner.signal)).resolves.toBe('abandoned');
-    });
-});
-async function* responseSource(terminal) {
-    yield Packet.toBinary({
-        body: {
-            case: 'callData',
-            value: {
-                data: response,
-                dataIsZero: false,
-                complete: false,
-                error: '',
-            },
-        },
-    });
-    await terminal;
-    yield Packet.toBinary({
-        body: {
-            case: 'callData',
-            value: {
-                data: new Uint8Array(),
-                dataIsZero: false,
-                complete: true,
-                error: '',
-            },
-        },
-    });
-}