@replit/river 0.8.0 → 0.9.0

package/README.md

@@ -8,6 +8,8 @@ It's like tRPC but...
 - with Result types and error handling
 - over WebSockets
 
+To use River, you must be on least Typescript 5 with `"moduleResolution": "bundler"`.
+
 ## Developing
 
 [![Run on Repl.it](https://replit.com/badge/github/replit/river)](https://replit.com/new/github/replit/river)

package/dist/__tests__/bandwidth.bench.js

@@ -1,7 +1,7 @@
 import http from 'http';
 import { assert, bench, describe } from 'vitest';
 import { createWebSocketServer, createWsTransports, onServerReady, } from '../util/testHelpers';
-import largePayload from './largePayload.json';
+import largePayload from './fixtures/largePayload.json';
 import { TestServiceConstructor } from './fixtures/services';
 import { createServer } from '../router/server';
 import { createClient } from '../router/client';

package/dist/__tests__/e2e.test.js

@@ -3,20 +3,19 @@ import { createLocalWebSocketClient, createWebSocketServer, createWsTransports,
 import { createServer } from '../router/server';
 import { createClient } from '../router/client';
 import http from 'http';
-import { BinaryFileServiceConstructor, DIV_BY_ZERO, FallibleServiceConstructor, OrderingServiceConstructor, STREAM_ERROR, SubscribableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
+import { BinaryFileServiceConstructor, DIV_BY_ZERO, FallibleServiceConstructor, OrderingServiceConstructor, STREAM_ERROR, SubscribableServiceConstructor, UploadableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
 import { UNCAUGHT_ERROR } from '../router/result';
 import { codecs } from '../codec/codec.test';
 import { WebSocketClientTransport } from '../transport/impls/ws/client';
 import { WebSocketServerTransport } from '../transport/impls/ws/server';
+import { testFinishesCleanly } from './fixtures/cleanup';
 describe.each(codecs)('client <-> server integration test ($name codec)', async ({ codec }) => {
     const httpServer = http.createServer();
     const port = await onServerReady(httpServer);
     const webSocketServer = await createWebSocketServer(httpServer);
     const getTransports = () => createWsTransports(port, webSocketServer, codec);
     afterAll(() => {
-        webSocketServer.clients.forEach((socket) => {
-            socket.close();
-        });
+        webSocketServer.close();
         httpServer.close();
     });
     test('rpc', async () => {
@@ -27,6 +26,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         const result = await client.test.add.rpc({ n: 3 });
         assert(result.ok);
         expect(result.payload).toStrictEqual({ result: 3 });
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('fallible rpc', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -45,6 +49,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
                 test: 'abc',
             },
         });
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('rpc with binary (uint8array)', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -55,6 +64,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         assert(result.ok);
         assert(result.payload.contents instanceof Uint8Array);
         expect(new TextDecoder().decode(result.payload.contents)).toStrictEqual('contents for file test.py');
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('stream', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -65,6 +79,7 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         input.push({ msg: 'abc', ignore: false });
         input.push({ msg: 'def', ignore: true });
         input.push({ msg: 'ghi', ignore: false });
+        input.push({ msg: 'end', ignore: false, end: true });
         input.end();
         const result1 = await iterNext(output);
         assert(result1.ok);
@@ -72,7 +87,43 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         const result2 = await iterNext(output);
         assert(result2.ok);
         expect(result2.payload).toStrictEqual({ response: 'ghi' });
+        const result3 = await iterNext(output);
+        assert(result3.ok);
+        expect(result3.payload).toStrictEqual({ response: 'end' });
+        // after the server stream is ended, the client stream should be ended too
+        const result4 = await output.next();
+        assert(result4.done);
         close();
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
+    });
+    test('stream with init message', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const [input, output, close] = await client.test.echoWithPrefix.stream({
+            prefix: 'test',
+        });
+        input.push({ msg: 'abc', ignore: false });
+        input.push({ msg: 'def', ignore: true });
+        input.push({ msg: 'ghi', ignore: false });
+        input.end();
+        const result1 = await iterNext(output);
+        assert(result1.ok);
+        expect(result1.payload).toStrictEqual({ response: 'test abc' });
+        const result2 = await iterNext(output);
+        assert(result2.ok);
+        expect(result2.payload).toStrictEqual({ response: 'test ghi' });
+        close();
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('fallible stream', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -96,6 +147,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
             message: 'some message',
         });
         close();
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('subscription', async () => {
         const options = { codec };
@@ -132,6 +188,49 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         expect(result.payload).toStrictEqual({ result: 4 });
         close1();
         close2();
+        await testFinishesCleanly({
+            clientTransports: [client1Transport, client2Transport],
+            serverTransport,
+            server,
+        });
+    });
+    test('upload', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { uploadable: UploadableServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const [addStream, addResult] = await client.uploadable.addMultiple.upload();
+        addStream.push({ n: 1 });
+        addStream.push({ n: 2 });
+        addStream.end();
+        const result = await addResult;
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 3 });
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
+    });
+    test('upload with init message', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { uploadable: UploadableServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const [addStream, addResult] = await client.uploadable.addMultipleWithPrefix.upload({
+            prefix: 'test',
+        });
+        addStream.push({ n: 1 });
+        addStream.push({ n: 2 });
+        addStream.end();
+        const result = await addResult;
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 'test 3' });
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('message order is preserved in the face of disconnects', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -153,7 +252,12 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
         }
         const res = await client.test.getAll.rpc({});
         assert(res.ok);
-        return expect(res.payload.msgs).toStrictEqual(expected);
+        expect(res.payload.msgs).toStrictEqual(expected);
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     const CONCURRENCY = 10;
     test('concurrent rpcs', async () => {
@@ -170,6 +274,11 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
             assert(result.ok);
             expect(result.payload).toStrictEqual({ n: i });
         }
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
     test('concurrent streams', async () => {
         const [clientTransport, serverTransport] = getTransports();
@@ -198,5 +307,10 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
             const [_input, _output, close] = openStreams[i];
             close();
         }
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
     });
 });

package/dist/__tests__/fixtures/cleanup.d.ts

@@ -0,0 +1,12 @@
+import { Connection, Transport } from '../../transport';
+import { Server } from '../../router';
+export declare function ensureTransportIsClean(t: Transport<Connection>): Promise<void>;
+export declare function waitUntil<T>(valueGetter: () => T, expected: T, message?: string): Promise<boolean>;
+export declare function ensureTransportQueuesAreEventuallyEmpty(t: Transport<Connection>): Promise<void>;
+export declare function ensureServerIsClean(s: Server<unknown>): Promise<boolean>;
+export declare function testFinishesCleanly({ clientTransports, serverTransport, server, }: Partial<{
+    clientTransports: Array<Transport<Connection>>;
+    serverTransport: Transport<Connection>;
+    server: Server<unknown>;
+}>): Promise<void>;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/__tests__/fixtures/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../../__tests__/fixtures/cleanup.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAOtC,wBAAsB,sBAAsB,CAAC,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,iBAapE;AAED,wBAAsB,SAAS,CAAC,CAAC,EAC/B,WAAW,EAAE,MAAM,CAAC,EACpB,QAAQ,EAAE,CAAC,EACX,OAAO,CAAC,EAAE,MAAM,oBAOjB;AAED,wBAAsB,uCAAuC,CAC3D,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,iBAazB;AAED,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC,oBAM3D;AAED,wBAAsB,mBAAmB,CAAC,EACxC,gBAAgB,EAChB,eAAe,EACf,MAAM,GACP,EAAE,OAAO,CAAC;IACT,gBAAgB,EAAE,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;IAC/C,eAAe,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;IACvC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;CACzB,CAAC,iBAgBD"}

package/dist/__tests__/fixtures/cleanup.js

@@ -0,0 +1,39 @@
+import { expect, vi } from 'vitest';
+const waitUntilOptions = {
+    timeout: 250,
+    interval: 5, // check every 5ms
+};
+export async function ensureTransportIsClean(t) {
+    expect(t.state, `transport ${t.clientId} should be closed after the test`).to.not.equal('open');
+    expect(t.connections, `transport ${t.clientId} should not have open connections after the test`).toStrictEqual(new Map());
+    expect(t.eventDispatcher.numberOfListeners('message'), `transport ${t.clientId} should not have open message handlers after the test`).equal(0);
+}
+export async function waitUntil(valueGetter, expected, message) {
+    return vi
+        .waitUntil(() => valueGetter() === expected, waitUntilOptions)
+        .finally(() => {
+        expect(valueGetter(), message).toEqual(expected);
+    });
+}
+export async function ensureTransportQueuesAreEventuallyEmpty(t) {
+    await waitUntil(() => t.sendQueue.size, 0, `transport ${t.clientId} should not have any messages waiting to send after the test`);
+    await waitUntil(() => t.sendBuffer.size, 0, `transport ${t.clientId} should not have any un-acked messages after the test`);
+}
+export async function ensureServerIsClean(s) {
+    return waitUntil(() => s.streams.size, 0, `server should not have any open streams after the test`);
+}
+export async function testFinishesCleanly({ clientTransports, serverTransport, server, }) {
+    if (clientTransports) {
+        await Promise.all(clientTransports.map((t) => t.close()));
+        await Promise.all(clientTransports.map(ensureTransportIsClean));
+    }
+    // server sits on top of server transport so we clean it up first
+    if (server) {
+        await ensureServerIsClean(server);
+        await server.close();
+    }
+    if (serverTransport) {
+        await serverTransport.close();
+        await ensureTransportIsClean(serverTransport);
+    }
+}

package/dist/__tests__/fixtures/services.d.ts

@@ -2,6 +2,7 @@ import { Observable } from './observable';
 export declare const EchoRequest: import("@sinclair/typebox").TObject<{
     msg: import("@sinclair/typebox").TString;
     ignore: import("@sinclair/typebox").TBoolean;
+    end: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
 }>;
 export declare const EchoResponse: import("@sinclair/typebox").TObject<{
     response: import("@sinclair/typebox").TString;
@@ -34,6 +35,7 @@ export declare const TestServiceConstructor: () => {
             input: import("@sinclair/typebox").TObject<{
                 msg: import("@sinclair/typebox").TString;
                 ignore: import("@sinclair/typebox").TBoolean;
+                end: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
             }>;
             output: import("@sinclair/typebox").TObject<{
                 response: import("@sinclair/typebox").TString;
@@ -42,6 +44,34 @@ export declare const TestServiceConstructor: () => {
             handler: (context: import("../../router").ServiceContextWithState<{
                 count: number;
             }>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+                end?: boolean | undefined;
+                msg: string;
+                ignore: boolean;
+            }>>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+                response: string;
+            }, never>>, void, unknown>) => Promise<void>;
+            type: "stream";
+        };
+    } & {
+        echoWithPrefix: {
+            init: import("@sinclair/typebox").TObject<{
+                prefix: import("@sinclair/typebox").TString;
+            }>;
+            input: import("@sinclair/typebox").TObject<{
+                msg: import("@sinclair/typebox").TString;
+                ignore: import("@sinclair/typebox").TBoolean;
+                end: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                response: import("@sinclair/typebox").TString;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../../router").ServiceContextWithState<{
+                count: number;
+            }>, init: import("../../transport/message").TransportMessage<{
+                prefix: string;
+            }>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+                end?: boolean | undefined;
                 msg: string;
                 ignore: boolean;
             }>>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
@@ -213,4 +243,46 @@ export declare const SubscribableServiceConstructor: () => {
         };
     };
 };
+export declare const UploadableServiceConstructor: () => {
+    name: "uploadable";
+    state: {};
+    procedures: {
+        addMultiple: {
+            input: import("@sinclair/typebox").TObject<{
+                n: import("@sinclair/typebox").TNumber;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                result: import("@sinclair/typebox").TNumber;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../../router").ServiceContextWithState<{}>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+                n: number;
+            }>>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+                result: number;
+            }, never>>>;
+            type: "upload";
+        };
+    } & {
+        addMultipleWithPrefix: {
+            init: import("@sinclair/typebox").TObject<{
+                prefix: import("@sinclair/typebox").TString;
+            }>;
+            input: import("@sinclair/typebox").TObject<{
+                n: import("@sinclair/typebox").TNumber;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                result: import("@sinclair/typebox").TString;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../../router").ServiceContextWithState<{}>, init: import("../../transport/message").TransportMessage<{
+                prefix: string;
+            }>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+                n: number;
+            }>>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+                result: string;
+            }, never>>>;
+            type: "upload";
+        };
+    };
+};
 //# sourceMappingURL=services.d.ts.map

package/dist/__tests__/fixtures/services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../__tests__/fixtures/services.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,WAAW;;;EAGtB,CAAC;AACH,eAAO,MAAM,YAAY;;EAA2C,CAAC;AAErE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BpB,CAAC;AAEhB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;CAc1B,CAAC;AAEhB,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiExB,CAAC;AAEhB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B5B,CAAC"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../__tests__/fixtures/services.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,WAAW;;;;EAItB,CAAC;AACH,eAAO,MAAM,YAAY;;EAA2C,CAAC;AAErE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDpB,CAAC;AAEhB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;CAc1B,CAAC;AAEhB,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiExB,CAAC;AAEhB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B5B,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC1B,CAAC"}

package/dist/__tests__/fixtures/services.js

@@ -6,6 +6,7 @@ import { Observable } from './observable';
 export const EchoRequest = Type.Object({
     msg: Type.String(),
     ignore: Type.Boolean(),
+    end: Type.Optional(Type.Boolean()),
 });
 export const EchoResponse = Type.Object({ response: Type.String() });
 export const TestServiceConstructor = () => ServiceBuilder.create('test')
@@ -34,6 +35,24 @@ export const TestServiceConstructor = () => ServiceBuilder.create('test')
             if (!req.ignore) {
                 returnStream.push(reply(msg, Ok({ response: req.msg })));
             }
+            if (req.end) {
+                returnStream.end();
+            }
+        }
+    },
+})
+    .defineProcedure('echoWithPrefix', {
+    type: 'stream',
+    init: Type.Object({ prefix: Type.String() }),
+    input: EchoRequest,
+    output: EchoResponse,
+    errors: Type.Never(),
+    async handler(_ctx, init, msgStream, returnStream) {
+        for await (const msg of msgStream) {
+            const req = msg.payload;
+            if (!req.ignore) {
+                returnStream.push(reply(msg, Ok({ response: `${init.payload.prefix} ${req.msg}` })));
+            }
         }
     },
 })
@@ -167,3 +186,39 @@ export const SubscribableServiceConstructor = () => ServiceBuilder.create('subsc
     },
 })
     .finalize();
+export const UploadableServiceConstructor = () => ServiceBuilder.create('uploadable')
+    .initialState({})
+    .defineProcedure('addMultiple', {
+    type: 'upload',
+    input: Type.Object({ n: Type.Number() }),
+    output: Type.Object({ result: Type.Number() }),
+    errors: Type.Never(),
+    async handler(_ctx, msgStream) {
+        let result = 0;
+        let lastMsg;
+        for await (const msg of msgStream) {
+            const { n } = msg.payload;
+            result += n;
+            lastMsg = msg;
+        }
+        return reply(lastMsg, Ok({ result: result }));
+    },
+})
+    .defineProcedure('addMultipleWithPrefix', {
+    type: 'upload',
+    init: Type.Object({ prefix: Type.String() }),
+    input: Type.Object({ n: Type.Number() }),
+    output: Type.Object({ result: Type.String() }),
+    errors: Type.Never(),
+    async handler(_ctx, init, msgStream) {
+        let result = 0;
+        let lastMsg;
+        for await (const msg of msgStream) {
+            const { n } = msg.payload;
+            result += n;
+            lastMsg = msg;
+        }
+        return reply(lastMsg, Ok({ result: init.payload.prefix + ' ' + result }));
+    },
+})
+    .finalize();

package/dist/__tests__/handler.test.js

@@ -1,6 +1,6 @@
-import { asClientRpc, asClientStream, asClientSubscription, iterNext, } from '../util/testHelpers';
+import { asClientRpc, asClientStream, asClientStreamWithInitialization, asClientSubscription, asClientUpload, asClientUploadWithInitialization, iterNext, } from '../util/testHelpers';
 import { assert, describe, expect, test } from 'vitest';
-import { DIV_BY_ZERO, FallibleServiceConstructor, STREAM_ERROR, SubscribableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
+import { DIV_BY_ZERO, FallibleServiceConstructor, STREAM_ERROR, SubscribableServiceConstructor, UploadableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
 import { UNCAUGHT_ERROR } from '../router/result';
 import { Observable } from './fixtures/observable';
 describe('server-side test', () => {
@@ -48,6 +48,20 @@ describe('server-side test', () => {
         expect(result2.payload).toStrictEqual({ response: 'ghi' });
         expect(output.readableLength).toBe(0);
     });
+    test('stream with initialization', async () => {
+        const [input, output] = asClientStreamWithInitialization(initialState, service.procedures.echoWithPrefix, { prefix: 'test' });
+        input.push({ msg: 'abc', ignore: false });
+        input.push({ msg: 'def', ignore: true });
+        input.push({ msg: 'ghi', ignore: false });
+        input.end();
+        const result1 = await iterNext(output);
+        assert(result1 && result1.ok);
+        expect(result1.payload).toStrictEqual({ response: 'test abc' });
+        const result2 = await iterNext(output);
+        assert(result2 && result2.ok);
+        expect(result2.payload).toStrictEqual({ response: 'test ghi' });
+        expect(output.readableLength).toBe(0);
+    });
     test('fallible stream', async () => {
         const service = FallibleServiceConstructor();
         const [input, output] = asClientStream({}, service.procedures.echo);
@@ -85,4 +99,23 @@ describe('server-side test', () => {
         assert(streamResult2 && streamResult1.ok);
         expect(streamResult2.payload).toStrictEqual({ result: 3 });
     });
+    test('uploads', async () => {
+        const service = UploadableServiceConstructor();
+        const [input, result] = asClientUpload({}, service.procedures.addMultiple);
+        input.push({ n: 1 });
+        input.push({ n: 2 });
+        input.end();
+        expect(await result).toStrictEqual({ ok: true, payload: { result: 3 } });
+    });
+    test('uploads with initialization', async () => {
+        const service = UploadableServiceConstructor();
+        const [input, result] = asClientUploadWithInitialization({}, service.procedures.addMultipleWithPrefix, { prefix: 'test' });
+        input.push({ n: 1 });
+        input.push({ n: 2 });
+        input.end();
+        expect(await result).toStrictEqual({
+            ok: true,
+            payload: { result: 'test 3' },
+        });
+    });
 });

package/dist/__tests__/invariants.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=invariants.test.d.ts.map

package/dist/__tests__/invariants.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariants.test.d.ts","sourceRoot":"","sources":["../../__tests__/invariants.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/invariants.test.js

@@ -0,0 +1,136 @@
+import { afterAll, assert, describe, expect, test } from 'vitest';
+import http from 'http';
+import { createWebSocketServer, createWsTransports, iterNext, onServerReady, } from '../util/testHelpers';
+import { SubscribableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
+import { createClient, createServer } from '../router';
+import { ensureServerIsClean, ensureTransportQueuesAreEventuallyEmpty, waitUntil, } from './fixtures/cleanup';
+describe('procedures should leave no trace after finishing', async () => {
+    const httpServer = http.createServer();
+    const port = await onServerReady(httpServer);
+    const webSocketServer = await createWebSocketServer(httpServer);
+    const getTransports = () => createWsTransports(port, webSocketServer);
+    afterAll(() => {
+        webSocketServer.close();
+        httpServer.close();
+    });
+    test('closing a transport from the client cleans up connection on the server', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        expect(clientTransport.connections.size).toEqual(0);
+        expect(serverTransport.connections.size).toEqual(0);
+        // start procedure
+        await client.test.add.rpc({ n: 3 });
+        // end procedure
+        expect(clientTransport.connections.size).toEqual(1);
+        expect(serverTransport.connections.size).toEqual(1);
+        // should be back to 0 connections after client closes
+        clientTransport.close();
+        expect(clientTransport.connections.size).toEqual(0);
+        await waitUntil(() => serverTransport.connections.size, 0, 'server should cleanup connection after client closes');
+    });
+    test('closing a transport from the server cleans up connection on the client', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        expect(clientTransport.connections.size).toEqual(0);
+        expect(serverTransport.connections.size).toEqual(0);
+        // start procedure
+        await client.test.add.rpc({ n: 3 });
+        // end procedure
+        expect(clientTransport.connections.size).toEqual(1);
+        expect(serverTransport.connections.size).toEqual(1);
+        // should be back to 0 connections after client closes
+        serverTransport.close();
+        expect(serverTransport.connections.size).toEqual(0);
+        await waitUntil(() => clientTransport.connections.size, 0, 'client should cleanup connection after server closes');
+    });
+    test('rpc', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
+        let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
+        // start procedure
+        await client.test.add.rpc({ n: 3 });
+        // end procedure
+        // number of message handlers shouldn't increase after rpc
+        expect(serverTransport.eventDispatcher.numberOfListeners('message')).toEqual(serverListeners);
+        expect(clientTransport.eventDispatcher.numberOfListeners('message')).toEqual(clientListeners);
+        // check number of connections
+        expect(serverTransport.connections.size).toEqual(1);
+        expect(clientTransport.connections.size).toEqual(1);
+        await ensureTransportQueuesAreEventuallyEmpty(clientTransport);
+        await ensureTransportQueuesAreEventuallyEmpty(serverTransport);
+        // ensure we have no streams left on the server
+        await ensureServerIsClean(server);
+    });
+    test('stream', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
+        let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
+        // start procedure
+        const [input, output, close] = await client.test.echo.stream();
+        input.push({ msg: '1', ignore: false });
+        input.push({ msg: '2', ignore: false, end: true });
+        input.end();
+        const result1 = await iterNext(output);
+        assert(result1.ok);
+        expect(result1.payload).toStrictEqual({ response: '1' });
+        const result2 = await iterNext(output);
+        assert(result2.ok);
+        expect(result2.payload).toStrictEqual({ response: '2' });
+        // ensure we exactly have one stream even after we send multiple messages
+        expect(server.streams.size).toEqual(1);
+        const result3 = await output.next();
+        assert(result3.done);
+        close();
+        // end procedure
+        // number of message handlers shouldn't increase after stream ends
+        expect(serverTransport.eventDispatcher.numberOfListeners('message')).toEqual(serverListeners);
+        expect(clientTransport.eventDispatcher.numberOfListeners('message')).toEqual(clientListeners);
+        // check number of connections
+        expect(serverTransport.connections.size).toEqual(1);
+        expect(clientTransport.connections.size).toEqual(1);
+        await ensureTransportQueuesAreEventuallyEmpty(clientTransport);
+        await ensureTransportQueuesAreEventuallyEmpty(serverTransport);
+        // ensure we have no streams left on the server
+        await ensureServerIsClean(server);
+    });
+    test('subscription', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: SubscribableServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
+        let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
+        // start procedure
+        const [subscription, close] = await client.test.value.subscribe({});
+        let result = await iterNext(subscription);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 0 });
+        const add1 = await client.test.add.rpc({ n: 1 });
+        assert(add1.ok);
+        result = await iterNext(subscription);
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 1 });
+        close();
+        // end procedure
+        // number of message handlers shouldn't increase after stream ends
+        expect(serverTransport.eventDispatcher.numberOfListeners('message')).toEqual(serverListeners);
+        expect(clientTransport.eventDispatcher.numberOfListeners('message')).toEqual(clientListeners);
+        // check number of connections
+        expect(serverTransport.connections.size).toEqual(1);
+        expect(clientTransport.connections.size).toEqual(1);
+        await ensureTransportQueuesAreEventuallyEmpty(clientTransport);
+        await ensureTransportQueuesAreEventuallyEmpty(serverTransport);
+        // ensure we have no streams left on the server
+        await ensureServerIsClean(server);
+    });
+});