starpc 0.52.0 → 0.52.1

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

@@ -1,4 +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>;
+export declare function runRpcStreamTest(client: Client, release?: boolean): Promise<void>;

package/dist/echo/client-test.js

@@ -1,7 +1,7 @@
 import { Client, ERR_RPC_ABORT } from '../srpc/index.js';
 import { EchoerClient } from './echo_srpc.pb.js';
 import { pushable } from 'it-pushable';
-import { buildRpcStreamOpenStream } from '../rpcstream/rpcstream.js';
+import { buildRpcStreamOpenStream, openRpcStream, } from '../rpcstream/rpcstream.js';
 export async function runClientTest(client) {
     const demoServiceClient = new EchoerClient(client);
     console.log('Calling Echo: unary call...');
@@ -77,8 +77,14 @@ export async function runAbortControllerTest(client) {
         }
     });
 }
+function requireError(error, label, fragments) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!fragments.some((fragment) => message.includes(fragment))) {
+        throw new Error(`${label} returned unexpected error: ${message}`);
+    }
+}
 // runRpcStreamTest tests a RPCStream.
-export async function runRpcStreamTest(client) {
+export async function runRpcStreamTest(client, release = false) {
     console.log('Calling RpcStream to open a RPC stream client...');
     const service = new EchoerClient(client);
     const openStreamFn = buildRpcStreamOpenStream('test', service.RpcStream.bind(service));
@@ -89,4 +95,106 @@ export async function runRpcStreamTest(client) {
     console.log('rpc stream test: succeeded: response: ' + resp.body);
     console.log('Running client test over RPC stream...');
     await runClientTest(proxiedClient);
+    if (release) {
+        let unknownRejected = false;
+        try {
+            await openRpcStream('missing', service.RpcStream.bind(service), true);
+        }
+        catch (error) {
+            unknownRejected = true;
+            requireError(error, 'unknown component', ['unknown component: missing']);
+        }
+        if (!unknownRejected) {
+            throw new Error('unknown component unexpectedly succeeded');
+        }
+    }
+    let methodRejected = false;
+    try {
+        await proxiedClient.request('missing.Service', 'Missing', new Uint8Array());
+    }
+    catch (error) {
+        methodRejected = true;
+        requireError(error, 'unknown nested method', [
+            'missing.Service',
+            'unimplemented',
+        ]);
+    }
+    if (!methodRejected) {
+        throw new Error('unknown nested method unexpectedly succeeded');
+    }
+    if (release) {
+        const terminalService = new EchoerClient(proxiedClient);
+        let terminalFailed = false;
+        try {
+            await terminalService.Echo({ body: '__nested_error__' });
+        }
+        catch (error) {
+            terminalFailed = true;
+            requireError(error, 'terminal nested error', ['nested terminal error']);
+        }
+        if (!terminalFailed) {
+            throw new Error('terminal nested error unexpectedly succeeded');
+        }
+    }
+    if (release) {
+        const releaseClient = new Client(buildRpcStreamOpenStream('release', service.RpcStream.bind(service)));
+        let releaseFailed = false;
+        const releaseService = new EchoerClient(releaseClient);
+        try {
+            await releaseService.Echo({ body: '__nested_release__' });
+        }
+        catch (error) {
+            releaseFailed = true;
+            requireError(error, 'release during active call', [
+                'closed before completion',
+                'stream closed',
+                'abort',
+                'cancel',
+            ]);
+        }
+        if (!releaseFailed) {
+            throw new Error('release during active call unexpectedly succeeded');
+        }
+        const releaseStatus = await service.Echo({
+            body: '__nested_release_status__',
+        });
+        if (releaseStatus.body !== 'released') {
+            throw new Error(`release completion returned ${releaseStatus.body}`);
+        }
+        let releasedRejected = false;
+        try {
+            await releaseService.Echo({});
+        }
+        catch (error) {
+            releasedRejected = true;
+            requireError(error, 'released component', ['unknown component: release']);
+        }
+        if (!releasedRejected) {
+            throw new Error('released component unexpectedly remained available');
+        }
+    }
+    const cancelled = new AbortController();
+    const cancelledStream = proxiedClient.bidirectionalStreamingRequest('echo.Echoer', 'EchoBidiStream', (async function* () {
+        yield new Uint8Array();
+        await new Promise(() => undefined);
+    })(), cancelled.signal);
+    const cancelledIterator = cancelledStream[Symbol.asyncIterator]();
+    const firstNestedResponse = await cancelledIterator.next();
+    if (firstNestedResponse.done) {
+        throw new Error('nested cancellation call ended before its first response');
+    }
+    cancelled.abort();
+    let cancelRejected = false;
+    try {
+        while (!(await cancelledIterator.next()).done) {
+            // Drain until the abort reaches the nested call.
+        }
+    }
+    catch (error) {
+        cancelRejected = true;
+        requireError(error, 'nested cancellation', [ERR_RPC_ABORT]);
+    }
+    if (!cancelRejected) {
+        throw new Error('nested cancellation unexpectedly completed normally');
+    }
 }

package/dist/integration/cross-language/tcp-packet-stream.d.ts

@@ -0,0 +1,3 @@
+import net from 'net';
+import type { PacketStream } from '../../srpc/stream.js';
+export declare function tcpSocketToPacketStream(socket: net.Socket): PacketStream;

package/dist/integration/cross-language/tcp-packet-stream.js

@@ -0,0 +1,112 @@
+import { pipe } from 'it-pipe';
+import { pushable } from 'it-pushable';
+import { combineUint8ArrayListTransform } from '../../srpc/array-list.js';
+import { parseLengthPrefixTransform, prependLengthPrefixTransform, } from '../../srpc/packet.js';
+import { closeIterator, sourceIterator, TerminationGate, } from '../../srpc/termination.js';
+// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
+export function tcpSocketToPacketStream(socket) {
+    const sourceTermination = new TerminationGate();
+    const sinkTermination = new TerminationGate();
+    const bytes = pushable({ objectMode: true });
+    let bytesEnded = false;
+    const endBytes = (error) => {
+        if (bytesEnded)
+            return;
+        bytesEnded = true;
+        bytes.end(error);
+    };
+    const terminate = (error) => {
+        const first = sourceTermination.terminate(error);
+        sinkTermination.terminate(error);
+        endBytes(error);
+        return first;
+    };
+    socket.on('data', (data) => {
+        if (!bytesEnded)
+            bytes.push(new Uint8Array(data));
+    });
+    socket.on('end', () => endBytes());
+    socket.on('error', (error) => terminate(error));
+    socket.on('close', () => {
+        endBytes();
+        sinkTermination.terminate();
+    });
+    const close = async () => {
+        if (terminate())
+            socket.destroy();
+    };
+    const abort = (error) => {
+        if (terminate(error))
+            socket.destroy(error);
+    };
+    return {
+        close,
+        abort,
+        source: (async function* () {
+            const packets = pipe(bytes, parseLengthPrefixTransform(), combineUint8ArrayListTransform())[Symbol.asyncIterator]();
+            try {
+                while (true) {
+                    const next = await sourceTermination.next(packets);
+                    if ('terminated' in next) {
+                        if (next.error)
+                            throw next.error;
+                        return;
+                    }
+                    if ('error' in next)
+                        throw next.error;
+                    if (next.result.done)
+                        return;
+                    yield next.result.value;
+                }
+            }
+            finally {
+                closeIterator(packets);
+            }
+        })(),
+        sink: async (source) => {
+            const iterator = sourceIterator(pipe(source, prependLengthPrefixTransform()));
+            try {
+                while (true) {
+                    const next = await sinkTermination.next(iterator);
+                    if ('terminated' in next) {
+                        if (next.error)
+                            throw next.error;
+                        return;
+                    }
+                    if ('error' in next)
+                        throw next.error;
+                    if (next.result.done) {
+                        socket.end();
+                        return;
+                    }
+                    const data = next.result.value instanceof Uint8Array
+                        ? next.result.value
+                        : next.result.value.subarray();
+                    const written = await sinkTermination.wait(new Promise((resolve, reject) => {
+                        socket.write(data, (error) => {
+                            if (error)
+                                reject(error);
+                            else
+                                resolve();
+                        });
+                    }));
+                    if ('terminated' in written) {
+                        if (written.error)
+                            throw written.error;
+                        return;
+                    }
+                    if ('error' in written)
+                        throw written.error;
+                }
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                abort(error);
+                throw error;
+            }
+            finally {
+                closeIterator(iterator);
+            }
+        },
+    };
+}

package/dist/integration/cross-language/tcp-packet-stream.test.d.ts

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

package/dist/integration/cross-language/tcp-packet-stream.test.js

@@ -0,0 +1,121 @@
+import net from 'net';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { pushable } from 'it-pushable';
+import { tcpSocketToPacketStream } from './tcp-packet-stream.js';
+const sockets = [];
+const servers = [];
+afterEach(() => {
+    for (const socket of sockets)
+        socket.destroy();
+    for (const server of servers)
+        server.close();
+    sockets.length = 0;
+    servers.length = 0;
+});
+describe('TCP PacketStream lifecycle', () => {
+    it('settles a blocked source when the peer ends cleanly', async () => {
+        const { local, peer } = await connectSockets();
+        const stream = tcpSocketToPacketStream(local);
+        const pending = stream.source.next();
+        peer.end();
+        await expect(settleBeforeTimeout(pending)).resolves.toEqual({
+            done: true,
+            value: undefined,
+        });
+    });
+    it('reports a truncated frame when the peer ends', async () => {
+        const { local, peer } = await connectSockets();
+        const stream = tcpSocketToPacketStream(local);
+        const pending = stream.source.next();
+        peer.end(Buffer.from([4, 0, 0, 0, 10, 1]));
+        await expect(settleBeforeTimeout(pending)).rejects.toThrow('truncated packet frame');
+    });
+    it('rejects a blocked source with the abort error', async () => {
+        const { local } = await connectSockets();
+        const stream = tcpSocketToPacketStream(local);
+        const pending = stream.source.next();
+        const error = new Error('stopped');
+        stream.abort(error);
+        await expect(settleBeforeTimeout(pending)).rejects.toBe(error);
+    });
+    it('settles a blocked sink when closed', async () => {
+        const { local } = await connectSockets();
+        const stream = tcpSocketToPacketStream(local);
+        const input = pushable({ objectMode: true });
+        const pending = stream.sink(input);
+        await stream.close();
+        await expect(pending).resolves.toBeUndefined();
+    });
+    it('settles an in-flight socket write when closed', async () => {
+        const { local } = await connectSockets();
+        const stream = tcpSocketToPacketStream(local);
+        const input = pushable({ objectMode: true });
+        const writeStarted = Promise.withResolvers();
+        vi.spyOn(local, 'write').mockImplementation(((_data, _callback) => {
+            writeStarted.resolve();
+            return true;
+        }));
+        input.push(new Uint8Array([1]));
+        const pending = stream.sink(input);
+        await writeStarted.promise;
+        await stream.close();
+        await expect(settleBeforeTimeout(pending)).resolves.toBeUndefined();
+    });
+    it('rejects a blocked sink with the abort error', async () => {
+        const { local } = await connectSockets();
+        const stream = tcpSocketToPacketStream(local);
+        const input = pushable({ objectMode: true });
+        const pending = stream.sink(input);
+        const error = new Error('stopped');
+        stream.abort(error);
+        await expect(pending).rejects.toBe(error);
+    });
+    it('does not write ready input after close', async () => {
+        const { local, peer } = await connectSockets();
+        const stream = tcpSocketToPacketStream(local);
+        const input = pushable({ objectMode: true });
+        const received = [];
+        peer.on('data', (data) => {
+            if (typeof data !== 'string')
+                received.push(data);
+        });
+        input.push(new Uint8Array([1]));
+        const pending = stream.sink(input);
+        await stream.close();
+        await pending;
+        await new Promise((resolve) => peer.once('close', () => resolve()));
+        expect(received).toEqual([]);
+    });
+});
+async function connectSockets() {
+    const accepted = Promise.withResolvers();
+    const server = net.createServer((socket) => accepted.resolve(socket));
+    servers.push(server);
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    const local = net.connect(address.port, address.address);
+    await new Promise((resolve, reject) => {
+        local.once('connect', resolve);
+        local.once('error', reject);
+    });
+    const peer = await accepted.promise;
+    sockets.push(local, peer);
+    return { local, peer };
+}
+async function settleBeforeTimeout(promise) {
+    let timeout;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => reject(new Error('source stayed blocked')), 500);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/integration/cross-language/ts-client.js

@@ -1,48 +1,51 @@
 import net from 'net';
-import { pipe } from 'it-pipe';
 import { pushable } from 'it-pushable';
 import { Client } from '../../srpc/client.js';
-import { parseLengthPrefixTransform, prependLengthPrefixTransform, } from '../../srpc/packet.js';
-import { combineUint8ArrayListTransform } from '../../srpc/array-list.js';
-import { runClientTest } from '../../echo/index.js';
-// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
-function tcpSocketToPacketStream(socket) {
-    const socketSource = async function* () {
-        const source = pushable({ objectMode: true });
-        socket.on('data', (data) => {
-            source.push(new Uint8Array(data));
-        });
-        socket.on('end', () => source.end());
-        socket.on('error', (err) => source.end(err));
-        socket.on('close', () => source.end());
-        yield* pipe(source, parseLengthPrefixTransform(), combineUint8ArrayListTransform());
-    };
-    return {
-        source: socketSource(),
-        sink: async (source) => {
-            for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
-                const data = chunk instanceof Uint8Array ? chunk : chunk.subarray();
-                await new Promise((resolve, reject) => {
-                    socket.write(data, (err) => {
-                        if (err)
-                            reject(err);
-                        else
-                            resolve();
-                    });
-                });
-            }
-            socket.end();
-        },
-    };
+import { runClientTest, runAbortControllerTest, runRpcStreamTest, } from '../../echo/client-test.js';
+import { EchoerClient } from '../../echo/echo_srpc.pb.js';
+import { tcpSocketToPacketStream } from './tcp-packet-stream.js';
+async function runEchoBidiStreamTest(client) {
+    const request = pushable({ objectMode: true });
+    const stream = new EchoerClient(client).EchoBidiStream(request);
+    const iterator = stream[Symbol.asyncIterator]();
+    const initial = await iterator.next();
+    if (initial.done || initial.value.body !== 'hello from server') {
+        throw new Error('expected initial bidi message "hello from server"');
+    }
+    const body = 'hello from TypeScript bidi client';
+    request.push({ body });
+    request.end();
+    const echo = await iterator.next();
+    if (echo.done || echo.value.body !== body) {
+        throw new Error(`expected bidi echo ${JSON.stringify(body)}`);
+    }
+    const terminal = await iterator.next();
+    if (!terminal.done) {
+        throw new Error('expected bidi stream to terminate after input closes');
+    }
+}
+function parseAddr(addr) {
+    const match = /^(?:\[([^\]]+)\]|([^:]+)):(\d+)$/.exec(addr);
+    if (!match) {
+        throw new Error(`invalid host:port address: ${addr}`);
+    }
+    const port = Number(match[3]);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`invalid port: ${match[3]}`);
+    }
+    return { host: match[1] ?? match[2], port };
 }
 async function main() {
-    const addr = process.argv[2];
+    const args = process.argv.slice(2);
+    const lifecycle = args.includes('lifecycle');
+    const nested = args.includes('--nested') || args.includes('--nested-release');
+    const nestedRelease = args.includes('--nested-release');
+    const addr = args.find((arg) => arg !== 'lifecycle' && arg !== '--nested' && arg !== '--nested-release');
     if (!addr) {
-        console.error('usage: ts-client <host:port>');
+        console.error('usage: ts-client [--nested] [--nested-release] [lifecycle] <host:port>');
         process.exit(1);
     }
-    const [host, portStr] = addr.split(':');
-    const port = parseInt(portStr, 10);
+    const { host, port } = parseAddr(addr);
     const openStream = async () => {
         const { promise, resolve, reject } = Promise.withResolvers();
         const socket = net.connect(port, host, () => {
@@ -54,6 +57,16 @@ async function main() {
     const client = new Client(openStream);
     console.log('Running client test via TCP...');
     await runClientTest(client);
+    console.log('Running EchoBidiStream test via TCP...');
+    await runEchoBidiStreamTest(client);
+    if (lifecycle) {
+        console.log('Running abort controller test via TCP...');
+        await runAbortControllerTest(client);
+    }
+    if (nested) {
+        console.log('Running RpcStream test via TCP...');
+        await runRpcStreamTest(client, nestedRelease);
+    }
     console.log('All tests passed.');
 }
 process.on('unhandledRejection', (ev) => {

package/dist/integration/cross-language/ts-server.js

@@ -1,43 +1,8 @@
 import net from 'net';
-import { pipe } from 'it-pipe';
-import { pushable } from 'it-pushable';
 import { createMux, createHandler, Server } from '../../srpc/index.js';
-import { parseLengthPrefixTransform, prependLengthPrefixTransform, } from '../../srpc/packet.js';
-import { combineUint8ArrayListTransform } from '../../srpc/array-list.js';
 import { EchoerServer } from '../../echo/index.js';
 import { EchoerDefinition } from '../../echo/echo_srpc.pb.js';
-// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
-// Each Uint8Array in source/sink is one packet (no length prefix).
-function tcpSocketToPacketStream(socket) {
-    // Source: read from socket, strip length prefix, yield individual packets.
-    const socketSource = async function* () {
-        const source = pushable({ objectMode: true });
-        socket.on('data', (data) => {
-            source.push(new Uint8Array(data));
-        });
-        socket.on('end', () => source.end());
-        socket.on('error', (err) => source.end(err));
-        socket.on('close', () => source.end());
-        yield* pipe(source, parseLengthPrefixTransform(), combineUint8ArrayListTransform());
-    };
-    return {
-        source: socketSource(),
-        sink: async (source) => {
-            for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
-                const data = chunk instanceof Uint8Array ? chunk : chunk.subarray();
-                await new Promise((resolve, reject) => {
-                    socket.write(data, (err) => {
-                        if (err)
-                            reject(err);
-                        else
-                            resolve();
-                    });
-                });
-            }
-            socket.end();
-        },
-    };
-}
+import { tcpSocketToPacketStream } from './tcp-packet-stream.js';
 const mux = createMux();
 const server = new Server(mux.lookupMethod);
 const echoer = new EchoerServer(server);

package/dist/rpcstream/rpcstream.d.ts

@@ -15,7 +15,11 @@ export declare class RpcStream implements PacketStream {
     readonly sink: Sink<Source<Uint8Array>, Promise<void>>;
     private readonly _packetRx;
     private readonly _packetTx;
-    constructor(packetTx: Pushable<Message<RpcStreamPacket>>, packetRx: AsyncIterator<Message<RpcStreamPacket>>);
+    private readonly _termination;
+    private readonly _cancelRpc;
+    constructor(packetTx: Pushable<Message<RpcStreamPacket>>, packetRx: AsyncIterator<Message<RpcStreamPacket>>, cancelRpc?: () => void);
+    close(): Promise<void>;
+    abort(err: Error): void;
     private _createSink;
     private _createSource;
 }