@replit/river 0.10.0 → 0.10.1

package/dist/__tests__/bandwidth.bench.js

@@ -1,90 +0,0 @@
-import http from 'http';
-import { assert, bench, describe } from 'vitest';
-import { createWebSocketServer, createWsTransports, onServerReady, waitForMessage, } from '../util/testHelpers';
-import largePayload from './fixtures/largePayload.json';
-import { TestServiceConstructor } from './fixtures/services';
-import { createServer } from '../router/server';
-import { createClient } from '../router/client';
-import { StupidlyLargeService } from './typescript-stress.test';
-import { buildServiceDefs } from '../router/defs';
-let smallId = 0;
-let largeId = 0;
-const dummyPayloadSmall = () => ({
-    id: `${smallId++}`,
-    from: 'client',
-    to: 'SERVER',
-    serviceName: 'test',
-    procedureName: 'test',
-    streamId: 'test',
-    controlFlags: 0,
-    payload: {
-        msg: 'cool',
-    },
-});
-const dummyPayloadLarge = () => ({
-    id: `${largeId++}`,
-    from: 'client',
-    to: 'SERVER',
-    serviceName: 'test',
-    procedureName: 'test',
-    streamId: 'test',
-    controlFlags: 0,
-    payload: largePayload,
-});
-const BENCH_DURATION = 1000;
-describe('transport level bandwidth', async () => {
-    const server = http.createServer();
-    const port = await onServerReady(server);
-    const webSocketServer = await createWebSocketServer(server);
-    const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
-    bench('send and recv (small payload)', async () => {
-        const id = clientTransport.send(dummyPayloadSmall());
-        await waitForMessage(serverTransport, (msg) => msg.id === id);
-        return;
-    }, { time: BENCH_DURATION });
-    bench('send and recv (large payload)', async () => {
-        const id = clientTransport.send(dummyPayloadLarge());
-        await waitForMessage(serverTransport, (msg) => msg.id === id);
-        return;
-    }, { time: BENCH_DURATION });
-});
-describe('simple router level bandwidth', async () => {
-    const httpServer = http.createServer();
-    const port = await onServerReady(httpServer);
-    const webSocketServer = await createWebSocketServer(httpServer);
-    const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
-    const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
-    const server = createServer(serverTransport, serviceDefs);
-    const client = createClient(clientTransport);
-    bench('rpc (wait for response)', async () => {
-        const result = await client.test.add.rpc({ n: 1 });
-        assert(result.ok);
-    }, { time: BENCH_DURATION });
-    const [input, output] = await client.test.echo.stream();
-    bench('stream (wait for response)', async () => {
-        input.push({ msg: 'abc', ignore: false });
-        const result = await output.next();
-        assert(result.value && result.value.ok);
-    }, { time: BENCH_DURATION });
-    bench('stream', async () => {
-        input.push({ msg: 'abc', ignore: false });
-    }, { time: BENCH_DURATION });
-});
-describe('complex (50 procedures) router level bandwidth', async () => {
-    const httpServer = http.createServer();
-    const port = await onServerReady(httpServer);
-    const webSocketServer = await createWebSocketServer(httpServer);
-    const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
-    const serviceDefs = buildServiceDefs([
-        StupidlyLargeService('a'),
-        StupidlyLargeService('b'),
-        StupidlyLargeService('c'),
-        StupidlyLargeService('d'),
-    ]);
-    const server = createServer(serverTransport, serviceDefs);
-    const client = createClient(clientTransport);
-    bench('rpc (wait for response)', async () => {
-        const result = await client.b.f35.rpc({ a: 1 });
-        assert(result.ok);
-    }, { time: BENCH_DURATION });
-});

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

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

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

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

package/dist/__tests__/cleanup.test.js

@@ -1,165 +0,0 @@
-import { afterAll, assert, describe, expect, test } from 'vitest';
-import http from 'http';
-import { createWebSocketServer, createWsTransports, iterNext, onServerReady, } from '../util/testHelpers';
-import { SubscribableServiceConstructor, TestServiceConstructor, UploadableServiceConstructor, } from './fixtures/services';
-import { createClient, createServer } from '../router';
-import { ensureServerIsClean, ensureTransportQueuesAreEventuallyEmpty, waitFor, } from './fixtures/cleanup';
-import { buildServiceDefs } from '../router/defs';
-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 = buildServiceDefs([TestServiceConstructor()]);
-        const server = 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 waitFor(() => expect(serverTransport.connections.size, 'server should cleanup connection after client closes').toEqual(0));
-    });
-    test('closing a transport from the server cleans up connection on the client', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
-        const server = 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 waitFor(() => expect(clientTransport.connections.size, 'client should cleanup connection after server closes').toEqual(0));
-    });
-    test('rpc', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
-        const server = 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 = buildServiceDefs([TestServiceConstructor()]);
-        const server = 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 });
-        const result1 = await iterNext(output);
-        assert(result1.ok);
-        expect(result1.payload).toStrictEqual({ response: '1' });
-        // ensure we only have one stream despite pushing multiple messages.
-        await waitFor(() => expect(server.streams.size).toEqual(1));
-        input.end();
-        // ensure we no longer have any streams since the input was closed.
-        await waitFor(() => expect(server.streams.size).toEqual(0));
-        const result2 = await iterNext(output);
-        assert(result2.ok);
-        expect(result2.payload).toStrictEqual({ response: '2' });
-        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 = buildServiceDefs([SubscribableServiceConstructor()]);
-        const server = 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.subscribable.value.subscribe({});
-        let result = await iterNext(subscription);
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 0 });
-        const add1 = await client.subscribable.add.rpc({ n: 1 });
-        assert(add1.ok);
-        result = await iterNext(subscription);
-        assert(result.ok);
-        close();
-        // end procedure
-        // number of message handlers shouldn't increase after subscription 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('upload', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = buildServiceDefs([UploadableServiceConstructor()]);
-        const server = createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
-        let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
-        // start procedure
-        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 });
-        // end procedure
-        // number of message handlers shouldn't increase after upload 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);
-    });
-});

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

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

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

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

package/dist/__tests__/disconnects.test.js

@@ -1,163 +0,0 @@
-import { afterAll, afterEach, assert, beforeEach, describe, expect, test, vi, } from 'vitest';
-import http from 'http';
-import { createLocalWebSocketClient, createWebSocketServer, createWsTransports, iterNext, onServerReady, } from '../util/testHelpers';
-import { SubscribableServiceConstructor, TestServiceConstructor, UploadableServiceConstructor, } from './fixtures/services';
-import { createClient, createServer } from '../router';
-import { ensureServerIsClean, waitFor } from './fixtures/cleanup';
-import { CONNECTION_GRACE_PERIOD_MS } from '../router/client';
-import { Err, UNEXPECTED_DISCONNECT } from '../router/result';
-import { WebSocketServerTransport } from '../transport/impls/ws/server';
-import { WebSocketClientTransport } from '../transport/impls/ws/client';
-import { buildServiceDefs } from '../router/defs';
-describe('procedures should handle unexpected disconnects', 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();
-    });
-    beforeEach(() => {
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    test('rpc', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
-        const server = createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        // start procedure
-        await client.test.add.rpc({ n: 3 });
-        expect(clientTransport.connections.size).toEqual(1);
-        expect(serverTransport.connections.size).toEqual(1);
-        clientTransport.connections.forEach((conn) => conn.ws.close());
-        clientTransport.tryReconnecting = false;
-        const procPromise = client.test.add.rpc({ n: 4 });
-        // end procedure
-        // after we've disconnected, hit end of grace period
-        await vi.runOnlyPendingTimersAsync();
-        await vi.advanceTimersByTimeAsync(CONNECTION_GRACE_PERIOD_MS);
-        // we should get an error + expect the streams to be cleaned up
-        await expect(procPromise).resolves.toMatchObject(Err({
-            code: UNEXPECTED_DISCONNECT,
-        }));
-        waitFor(() => expect(clientTransport.connections.size).toEqual(0));
-        waitFor(() => expect(serverTransport.connections.size).toEqual(0));
-        await ensureServerIsClean(server);
-    });
-    test('stream', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = buildServiceDefs([TestServiceConstructor()]);
-        const server = createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        // start procedure
-        const [input, output] = await client.test.echo.stream();
-        input.push({ msg: 'abc', ignore: false });
-        const result = await iterNext(output);
-        assert(result.ok);
-        expect(clientTransport.connections.size).toEqual(1);
-        expect(serverTransport.connections.size).toEqual(1);
-        clientTransport.connections.forEach((conn) => conn.ws.close());
-        clientTransport.tryReconnecting = false;
-        const nextResPromise = iterNext(output);
-        // end procedure
-        // after we've disconnected, hit end of grace period
-        await vi.runOnlyPendingTimersAsync();
-        await vi.advanceTimersByTimeAsync(CONNECTION_GRACE_PERIOD_MS);
-        // we should get an error + expect the streams to be cleaned up
-        await expect(nextResPromise).resolves.toMatchObject(Err({
-            code: UNEXPECTED_DISCONNECT,
-        }));
-        waitFor(() => expect(clientTransport.connections.size).toEqual(0));
-        waitFor(() => expect(serverTransport.connections.size).toEqual(0));
-        await ensureServerIsClean(server);
-    });
-    test('subscription', async () => {
-        const serverTransport = new WebSocketServerTransport(webSocketServer, 'SERVER');
-        const client1Transport = new WebSocketClientTransport(() => createLocalWebSocketClient(port), 'client1', 'SERVER');
-        const client2Transport = new WebSocketClientTransport(() => createLocalWebSocketClient(port), 'client2', 'SERVER');
-        const serviceDefs = buildServiceDefs([SubscribableServiceConstructor()]);
-        const server = createServer(serverTransport, serviceDefs);
-        const client1 = createClient(client1Transport);
-        const client2 = createClient(client2Transport);
-        // start procedure
-        // client1 and client2 both subscribe
-        const [subscription1, close1] = await client1.subscribable.value.subscribe({});
-        let result = await iterNext(subscription1);
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 0 });
-        const [subscription2, _close2] = await client2.subscribable.value.subscribe({});
-        result = await iterNext(subscription2);
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 0 });
-        // client2 adds a value
-        const add1 = await client2.subscribable.add.rpc({ n: 1 });
-        assert(add1.ok);
-        // both clients should receive the updated value
-        result = await iterNext(subscription1);
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 1 });
-        result = await iterNext(subscription2);
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 1 });
-        // all clients are connected
-        expect(client1Transport.connections.size).toEqual(1);
-        expect(client2Transport.connections.size).toEqual(1);
-        expect(serverTransport.connections.size).toEqual(2);
-        // kill the connection for client2
-        client2Transport.connections.forEach((conn) => conn.ws.close());
-        client2Transport.tryReconnecting = false;
-        // client1 who is still connected can still add values and receive updates
-        const add2Promise = client1.subscribable.add.rpc({ n: 2 });
-        // after we've disconnected, hit end of grace period
-        await vi.runOnlyPendingTimersAsync();
-        await vi.advanceTimersByTimeAsync(CONNECTION_GRACE_PERIOD_MS);
-        // we should get an error from the subscription on client2
-        const nextResPromise = iterNext(subscription2);
-        await expect(nextResPromise).resolves.toMatchObject(Err({
-            code: UNEXPECTED_DISCONNECT,
-        }));
-        // client1 who is still connected can still add values and receive updates
-        assert((await add2Promise).ok);
-        result = await iterNext(subscription1);
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 3 });
-        // at this point, only client1 is connected
-        expect(client1Transport.connections.size).toEqual(1);
-        expect(client2Transport.connections.size).toEqual(0);
-        expect(serverTransport.connections.size).toEqual(1);
-        // cleanup client1 (client2 is already disconnected)
-        close1();
-        await client1Transport.close();
-        await ensureServerIsClean(server);
-    });
-    test('upload', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = buildServiceDefs([UploadableServiceConstructor()]);
-        const server = createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        // start procedure
-        const [addStream, addResult] = await client.uploadable.addMultiple.upload();
-        addStream.push({ n: 1 });
-        addStream.push({ n: 2 });
-        // end procedure
-        // need to wait for connection to be established
-        await waitFor(() => expect(clientTransport.connections.size).toEqual(1));
-        await waitFor(() => expect(serverTransport.connections.size).toEqual(1));
-        clientTransport.connections.forEach((conn) => conn.ws.close());
-        clientTransport.tryReconnecting = false;
-        // after we've disconnected, hit end of grace period
-        await vi.runOnlyPendingTimersAsync();
-        await vi.advanceTimersByTimeAsync(CONNECTION_GRACE_PERIOD_MS);
-        // we should get an error + expect the streams to be cleaned up
-        await expect(addResult).resolves.toMatchObject(Err({
-            code: UNEXPECTED_DISCONNECT,
-        }));
-        waitFor(() => expect(clientTransport.connections.size).toEqual(0));
-        waitFor(() => expect(serverTransport.connections.size).toEqual(0));
-        await ensureServerIsClean(server);
-    });
-});

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

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

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

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