@replit/river 0.1.10 → 0.2.1

package/README.md

@@ -6,13 +6,3 @@ It's like tRPC but...
 - with full-duplex streaming
 - with support for service multiplexing
 - over WebSockets
-
-## Levels of abstraction
-
-- Router
-- Service
-- Procedure
-
-## TODO
-
-- support broadcast

package/dist/__tests__/bandwidth.bench.d.ts

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

package/dist/__tests__/bandwidth.bench.js

@@ -0,0 +1,82 @@
+import http from 'http';
+import { bench, describe } from 'vitest';
+import { createWebSocketServer, createWsTransports, onServerReady, waitForMessage, } from '../transport/util';
+import largePayload from './largePayload.json';
+import { TestServiceConstructor } from './integration.test';
+import { createServer } from '../router/server';
+import { createClient } from '../router/client';
+import { StupidlyLargeService } from './typescript-stress.test';
+let smallId = 0;
+let largeId = 0;
+const dummyPayloadSmall = () => ({
+    id: `${smallId++}`,
+    from: 'client',
+    to: 'SERVER',
+    serviceName: 'test',
+    procedureName: 'test',
+    payload: {
+        msg: 'cool',
+    },
+});
+const dummyPayloadLarge = () => ({
+    id: `${largeId++}`,
+    from: 'client',
+    to: 'SERVER',
+    serviceName: 'test',
+    procedureName: 'test',
+    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 = { test: TestServiceConstructor() };
+    const server = await createServer(serverTransport, serviceDefs);
+    const client = createClient(clientTransport);
+    bench('rpc (wait for response)', async () => {
+        await client.test.add({ n: 1 });
+    }, { time: BENCH_DURATION });
+    const [input, output] = await client.test.echo();
+    bench('stream (wait for response)', async () => {
+        input.push({ msg: 'abc', ignore: false });
+        await output.next();
+    }, { 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 = {
+        a: StupidlyLargeService(),
+        b: StupidlyLargeService(),
+        c: StupidlyLargeService(),
+        d: StupidlyLargeService(),
+    };
+    const server = await createServer(serverTransport, serviceDefs);
+    const client = createClient(clientTransport);
+    bench('rpc (wait for response)', async () => {
+        await client.b.f35({ a: 1 });
+    }, { time: BENCH_DURATION });
+});

package/dist/__tests__/integration.test.js

@@ -2,7 +2,7 @@ import http from 'http';
 import { Type } from '@sinclair/typebox';
 import { ServiceBuilder, serializeService } from '../router/builder';
 import { reply } from '../transport/message';
-import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+import { afterAll, describe, expect, test } from 'vitest';
 import { createWebSocketServer, createWsTransports, onServerReady, } from '../transport/util';
 import { createServer } from '../router/server';
 import { createClient } from '../router/client';
@@ -40,6 +40,29 @@ export const TestServiceConstructor = () => ServiceBuilder.create('test')
     },
 })
     .finalize();
+const OrderingServiceConstructor = () => ServiceBuilder.create('test')
+    .initialState({
+    msgs: [],
+})
+    .defineProcedure('add', {
+    type: 'rpc',
+    input: Type.Object({ n: Type.Number() }),
+    output: Type.Object({ ok: Type.Boolean() }),
+    async handler(ctx, msg) {
+        const { n } = msg.payload;
+        ctx.state.msgs.push(n);
+        return reply(msg, { ok: true });
+    },
+})
+    .defineProcedure('getAll', {
+    type: 'rpc',
+    input: Type.Object({}),
+    output: Type.Object({ msgs: Type.Array(Type.Number()) }),
+    async handler(ctx, msg) {
+        return reply(msg, { msgs: ctx.state.msgs });
+    },
+})
+    .finalize();
 test('serialize service to jsonschema', () => {
     const service = TestServiceConstructor();
     expect(serializeService(service)).toStrictEqual({
@@ -96,59 +119,76 @@ describe('server-side test', () => {
         await expect(add({ n: 6 })).resolves.toStrictEqual({ result: 11 });
     });
     test('stream basic', async () => {
-        const [i, o] = asClientStream(initialState, service.procedures.echo);
-        i.push({ msg: 'abc', ignore: false });
-        i.push({ msg: 'def', ignore: true });
-        i.push({ msg: 'ghi', ignore: false });
-        i.end();
-        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({
+        const [input, output] = asClientStream(initialState, service.procedures.echo);
+        input.push({ msg: 'abc', ignore: false });
+        input.push({ msg: 'def', ignore: true });
+        input.push({ msg: 'ghi', ignore: false });
+        input.end();
+        await expect(output.next().then((res) => res.value)).resolves.toStrictEqual({
             response: 'abc',
         });
-        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({
+        await expect(output.next().then((res) => res.value)).resolves.toStrictEqual({
             response: 'ghi',
         });
-        expect(o.readableLength).toBe(0);
+        expect(output.readableLength).toBe(0);
     });
 });
-const port = 4445;
-describe('client <-> server integration test', () => {
+describe('client <-> server integration test', async () => {
     const server = http.createServer();
-    let wss;
-    beforeAll(async () => {
-        await onServerReady(server, port);
-        wss = await createWebSocketServer(server);
-    });
+    const port = await onServerReady(server);
+    const webSocketServer = await createWebSocketServer(server);
     afterAll(() => {
-        wss.clients.forEach((socket) => {
+        webSocketServer.clients.forEach((socket) => {
             socket.close();
         });
         server.close();
     });
     test('rpc', async () => {
-        const [ct, st] = await createWsTransports(port, wss);
+        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
         const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(st, serviceDefs);
-        const client = createClient(ct);
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
         await expect(client.test.add({ n: 3 })).resolves.toStrictEqual({
             result: 3,
         });
     });
     test('stream', async () => {
-        const [ct, st] = await createWsTransports(port, wss);
+        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
         const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(st, serviceDefs);
-        const client = createClient(ct);
-        const [i, o, close] = await client.test.echo();
-        i.push({ msg: 'abc', ignore: false });
-        i.push({ msg: 'def', ignore: true });
-        i.push({ msg: 'ghi', ignore: false });
-        i.end();
-        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const [input, output, close] = await client.test.echo();
+        input.push({ msg: 'abc', ignore: false });
+        input.push({ msg: 'def', ignore: true });
+        input.push({ msg: 'ghi', ignore: false });
+        input.end();
+        await expect(output.next().then((res) => res.value)).resolves.toStrictEqual({
             response: 'abc',
         });
-        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({
+        await expect(output.next().then((res) => res.value)).resolves.toStrictEqual({
             response: 'ghi',
         });
         close();
     });
+    test('message order is preserved in the face of disconnects', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
+        const serviceDefs = { test: OrderingServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const expected = [];
+        for (let i = 0; i < 50; i++) {
+            expected.push(i);
+            if (i == 10) {
+                clientTransport.ws?.close();
+            }
+            if (i == 42) {
+                clientTransport.ws?.terminate();
+            }
+            await client.test.add({
+                n: i,
+            });
+        }
+        const res = await client.test.getAll({});
+        return expect(res.msgs).toStrictEqual(expected);
+    });
 });

package/dist/__tests__/largePayload.json

@@ -0,0 +1,33 @@
+{
+    "data": [
+        {
+            "type": "articles",
+            "id": "1",
+            "attributes": {
+                "title": "Example article",
+                "body": "The shortest article. Ever.",
+                "created": "2015-05-22T14:56:29.000Z",
+                "updated": "2015-05-22T14:56:28.000Z"
+            },
+            "relationships": {
+                "author": {
+                    "data": {
+                        "id": "42",
+                        "type": "people"
+                    }
+                }
+            }
+        }
+    ],
+    "included": [
+        {
+            "type": "people",
+            "id": "42",
+            "attributes": {
+                "name": "John",
+                "age": 21,
+                "gender": "male"
+            }
+        }
+    ]
+}