@replit/river 0.1.9 → 0.2.0

package/dist/__tests__/typescript-stress.test.js

@@ -6,17 +6,19 @@ import { createServer } from '../router/server';
 import { Transport } from '../transport/types';
 import { NaiveJsonCodec } from '../codec/json';
 import { createClient } from '../router/client';
+const input = Type.Object({ a: Type.Number() });
+const output = Type.Object({ b: Type.Number() });
 const fnBody = {
     type: 'rpc',
-    input: Type.Object({ a: Type.Number() }),
-    output: Type.Object({ b: Type.Number() }),
+    input,
+    output,
     async handler(_state, msg) {
         return reply(msg, { b: msg.payload.a });
     },
 };
 // typescript is limited to max 50 constraints
 // see: https://github.com/microsoft/TypeScript/issues/33541
-const svc = () => ServiceBuilder.create('test')
+export const StupidlyLargeService = () => ServiceBuilder.create('test')
     .defineProcedure('f1', fnBody)
     .defineProcedure('f2', fnBody)
     .defineProcedure('f3', fnBody)
@@ -80,14 +82,14 @@ export class MockTransport extends Transport {
 }
 describe("ensure typescript doesn't give up trying to infer the types for large services", () => {
     test('service with many procedures hits typescript limit', () => {
-        expect(serializeService(svc())).toBeTruthy();
+        expect(serializeService(StupidlyLargeService())).toBeTruthy();
     });
     test('serverclient should support many services with many procedures', async () => {
         const listing = {
-            a: svc(),
-            b: svc(),
-            c: svc(),
-            d: svc(),
+            a: StupidlyLargeService(),
+            b: StupidlyLargeService(),
+            c: StupidlyLargeService(),
+            d: StupidlyLargeService(),
         };
         const server = await createServer(new MockTransport('SERVER'), listing);
         const client = createClient(new MockTransport('client'));

package/dist/index.d.ts

@@ -11,4 +11,4 @@ export { TransportMessageSchema, OpaqueTransportMessageSchema, TransportAckSchem
 export type { TransportMessage, MessageId, OpaqueTransportMessage, TransportClientId, TransportMessageAck, } from './transport/message';
 export { StreamTransport } from './transport/stream';
 export { WebSocketTransport } from './transport/ws';
-export { createWebSocketServer, onServerReady, createWsTransports, waitForMessage, waitForSocketReady, createWebSocketClient, } from './transport/util';
+export { createWebSocketServer, onServerReady, createWsTransports, waitForMessage, createLocalWebSocketClient, } from './transport/util';

package/dist/index.js

@@ -6,4 +6,4 @@ export { Transport } from './transport/types';
 export { TransportMessageSchema, OpaqueTransportMessageSchema, TransportAckSchema, msg, payloadToTransportMessage, ack, reply, } from './transport/message';
 export { StreamTransport } from './transport/stream';
 export { WebSocketTransport } from './transport/ws';
-export { createWebSocketServer, onServerReady, createWsTransports, waitForMessage, waitForSocketReady, createWebSocketClient, } from './transport/util';
+export { createWebSocketServer, onServerReady, createWsTransports, waitForMessage, createLocalWebSocketClient, } from './transport/util';

package/dist/router/client.js

@@ -23,28 +23,28 @@ export const createClient = (transport) => _createRecursiveProxy(async (opts) =>
     const [input] = opts.args;
     if (input === undefined) {
         // stream case
-        const i = pushable({ objectMode: true });
-        const o = pushable({ objectMode: true });
-        // i -> transport
+        const inputStream = pushable({ objectMode: true });
+        const outputStream = pushable({ objectMode: true });
+        // input -> transport
         // this gets cleaned up on i.end() which is called by closeHandler
         (async () => {
-            for await (const rawIn of i) {
+            for await (const rawIn of inputStream) {
                 transport.send(msg(transport.clientId, 'SERVER', serviceName, procName, rawIn));
             }
         })();
-        // transport -> o
+        // transport -> output
         const listener = (msg) => {
             if (msg.serviceName === serviceName && msg.procedureName === procName) {
-                o.push(msg.payload);
+                outputStream.push(msg.payload);
             }
         };
         transport.addMessageListener(listener);
         const closeHandler = () => {
-            i.end();
-            o.end();
+            inputStream.end();
+            outputStream.end();
             transport.removeMessageListener(listener);
         };
-        return [i, o, closeHandler];
+        return [inputStream, outputStream, closeHandler];
     }
     else {
         // rpc case

package/dist/transport/message.d.ts

@@ -30,6 +30,7 @@ export type MessageId = string;
 export type OpaqueTransportMessage = TransportMessage<unknown>;
 export type TransportClientId = 'SERVER' | string;
 export declare const TransportAckSchema: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
     from: import("@sinclair/typebox").TString;
     ack: import("@sinclair/typebox").TString;
 }>;

package/dist/transport/message.js

@@ -12,6 +12,7 @@ export const TransportMessageSchema = (t) => Type.Object({
 });
 export const OpaqueTransportMessageSchema = TransportMessageSchema(Type.Unknown());
 export const TransportAckSchema = Type.Object({
+    id: Type.String(),
     from: Type.String(),
     ack: Type.String(),
 });
@@ -30,6 +31,7 @@ export function payloadToTransportMessage(payload) {
 }
 export function ack(msg) {
     return {
+        id: nanoid(),
         from: msg.to,
         ack: msg.id,
     };

package/dist/transport/types.js

@@ -12,6 +12,7 @@ export class Transport {
         this.clientId = clientId;
     }
     onMessage(msg) {
+        // TODO: try catch from string buf
         const parsedMsg = this.codec.fromStringBuf(msg.toString());
         if (Value.Check(TransportAckSchema, parsedMsg)) {
             // process ack
@@ -30,6 +31,9 @@ export class Transport {
             }
             this.send(ack(parsedMsg));
         }
+        else {
+            // TODO: warn on malformed
+        }
     }
     addMessageListener(handler) {
         this.handlers.add(handler);

package/dist/transport/util.d.ts

@@ -3,10 +3,10 @@ import http from 'http';
 import WebSocket from 'isomorphic-ws';
 import { WebSocketServer } from 'ws';
 import { Transport } from './types';
+import { WebSocketTransport } from './ws';
 import { OpaqueTransportMessage } from './message';
 export declare function createWebSocketServer(server: http.Server): Promise<WebSocket.Server<typeof WebSocket, typeof http.IncomingMessage>>;
-export declare function onServerReady(server: http.Server, port: number): Promise<void>;
-export declare function createWsTransports(port: number, wss: WebSocketServer): Promise<[Transport, Transport]>;
-export declare function waitForSocketReady(socket: WebSocket): Promise<void>;
-export declare function createWebSocketClient(port: number): Promise<WebSocket>;
+export declare function onServerReady(server: http.Server): Promise<number>;
+export declare function createLocalWebSocketClient(port: number): Promise<WebSocket>;
+export declare function createWsTransports(port: number, wss: WebSocketServer): [WebSocketTransport, WebSocketTransport];
 export declare function waitForMessage(t: Transport, filter?: (msg: OpaqueTransportMessage) => boolean): Promise<unknown>;

package/dist/transport/util.js

@@ -4,31 +4,36 @@ import { WebSocketTransport } from './ws';
 export async function createWebSocketServer(server) {
     return new WebSocketServer({ server });
 }
-export async function onServerReady(server, port) {
-    return new Promise((resolve) => {
-        server.listen(port, resolve);
-    });
-}
-export async function createWsTransports(port, wss) {
-    return new Promise((resolve) => {
-        const clientSockPromise = createWebSocketClient(port);
-        wss.on('connection', async (serverSock) => {
-            resolve([
-                new WebSocketTransport(await clientSockPromise, 'client'),
-                new WebSocketTransport(serverSock, 'SERVER'),
-            ]);
+export async function onServerReady(server) {
+    return new Promise((resolve, reject) => {
+        server.listen(() => {
+            const addr = server.address();
+            if (typeof addr === 'object' && addr) {
+                resolve(addr.port);
+            }
+            else {
+                reject(new Error("couldn't find a port to allocate"));
+            }
         });
     });
 }
-export async function waitForSocketReady(socket) {
-    return new Promise((resolve) => {
-        socket.addEventListener('open', () => resolve());
-    });
+export async function createLocalWebSocketClient(port) {
+    return new WebSocket(`ws://localhost:${port}`);
 }
-export async function createWebSocketClient(port) {
-    const client = new WebSocket(`ws://localhost:${port}`);
-    await waitForSocketReady(client);
-    return client;
+export function createWsTransports(port, wss) {
+    return [
+        new WebSocketTransport(async () => {
+            return createLocalWebSocketClient(port);
+        }, 'client'),
+        new WebSocketTransport(async () => {
+            return new Promise((resolve) => {
+                wss.on('connection', async function onConnect(serverSock) {
+                    wss.removeListener('connection', onConnect);
+                    resolve(serverSock);
+                });
+            });
+        }, 'SERVER'),
+    ];
 }
 export async function waitForMessage(t, filter) {
     return new Promise((resolve, _reject) => {

package/dist/transport/ws.d.ts

@@ -1,10 +1,25 @@
 /// <reference types="ws" />
-import type WebSocket from 'isomorphic-ws';
+import WebSocket from 'isomorphic-ws';
 import { Transport } from './types';
 import { MessageId, OpaqueTransportMessage, TransportClientId } from './message';
-export declare class WebSocketTransport extends Transport {
+interface Options {
+    retryIntervalMs: number;
+}
+type WebSocketResult = {
     ws: WebSocket;
-    constructor(ws: WebSocket, clientId: TransportClientId);
+} | {
+    err: string;
+};
+export declare class WebSocketTransport extends Transport {
+    wsGetter: () => Promise<WebSocket>;
+    ws?: WebSocket;
+    destroyed: boolean;
+    reconnectPromise?: Promise<WebSocketResult>;
+    options: Options;
+    sendQueue: Array<MessageId>;
+    constructor(wsGetter: () => Promise<WebSocket>, clientId: TransportClientId, options?: Partial<Options>);
+    private tryConnect;
     send(msg: OpaqueTransportMessage): MessageId;
-    close(): Promise<void>;
+    close(): Promise<void | undefined>;
 }
+export {};

package/dist/transport/ws.js

@@ -1,23 +1,88 @@
 import { Transport } from './types';
 import { NaiveJsonCodec } from '../codec/json';
-// TODO should answer:
-// - how do we handle graceful client disconnects? (i.e. close tab)
-// - how do we handle graceful service disconnects (i.e. a fuck off message)?
-// - how do we handle forceful client disconnects? (i.e. broken connection, offline)
-// - how do we handle forceful service disconnects (i.e. a crash)?
+const defaultOptions = {
+    retryIntervalMs: 250,
+};
 export class WebSocketTransport extends Transport {
+    wsGetter;
     ws;
-    constructor(ws, clientId) {
+    destroyed;
+    reconnectPromise;
+    options;
+    sendQueue;
+    constructor(wsGetter, clientId, options) {
         super(NaiveJsonCodec, clientId);
-        this.ws = ws;
-        ws.on('message', (msg) => this.onMessage(msg.toString()));
+        this.destroyed = false;
+        this.wsGetter = wsGetter;
+        this.options = { ...defaultOptions, ...options };
+        this.sendQueue = [];
+        this.tryConnect();
+    }
+    // postcondition: ws is concretely a WebSocket
+    async tryConnect() {
+        // wait until it's ready or we get an error
+        this.reconnectPromise ??= new Promise(async (resolve) => {
+            const ws = await this.wsGetter();
+            if (ws.readyState === ws.OPEN) {
+                return resolve({ ws });
+            }
+            if (ws.readyState === ws.CLOSING || ws.readyState === ws.CLOSED) {
+                return resolve({ err: 'ws is closing or closed' });
+            }
+            ws.addEventListener('open', function onOpen() {
+                ws.removeEventListener('open', onOpen);
+                resolve({ ws });
+            });
+            ws.addEventListener('error', function onError(err) {
+                ws.removeEventListener('error', onError);
+                resolve({ err: err.message });
+            });
+            ws.addEventListener('close', function onClose(evt) {
+                ws.removeEventListener('close', onClose);
+                resolve({ err: evt.reason });
+            });
+        });
+        const res = await this.reconnectPromise;
+        // only send if we resolved a valid websocket
+        if ('ws' in res && res.ws.readyState === res.ws.OPEN) {
+            this.ws = res.ws;
+            this.ws.onmessage = (msg) => this.onMessage(msg.data.toString());
+            this.ws.onclose = () => {
+                this.reconnectPromise = undefined;
+                this.tryConnect().catch();
+            };
+            // send outstanding
+            for (const id of this.sendQueue) {
+                const msg = this.sendBuffer.get(id);
+                if (!msg) {
+                    throw new Error('tried to resend a message we received an ack for');
+                }
+                this.ws.send(this.codec.toStringBuf(msg));
+            }
+            this.sendQueue = [];
+            return;
+        }
+        // otherwise try and reconnect again
+        this.reconnectPromise = undefined;
+        setTimeout(() => this.tryConnect(), this.options.retryIntervalMs);
     }
     send(msg) {
         const id = msg.id;
-        this.ws.send(this.codec.toStringBuf(msg));
+        if (this.destroyed) {
+            throw new Error('ws is destroyed, cant send');
+        }
+        this.sendBuffer.set(id, msg);
+        if (this.ws && this.ws.readyState === this.ws.OPEN) {
+            this.ws.send(this.codec.toStringBuf(msg));
+        }
+        else {
+            this.sendQueue.push(id);
+            this.tryConnect().catch();
+        }
         return id;
     }
     async close() {
-        return this.ws.close();
+        this.destroyed = true;
+        return this.ws?.close();
     }
 }

package/dist/transport/ws.test.js

@@ -1,15 +1,22 @@
 import http from 'http';
-import { WebSocketTransport } from './ws';
-import { describe, test, expect, beforeAll, afterAll } from 'vitest';
-import { createWebSocketClient, createWebSocketServer, onServerReady, waitForMessage, } from './util';
-const port = 3000;
-describe('sending and receiving across websockets works', () => {
+import { describe, test, expect, afterAll } from 'vitest';
+import { createWebSocketServer, createWsTransports, onServerReady, waitForMessage, } from './util';
+import { nanoid } from 'nanoid';
+const getMsg = () => ({
+    id: nanoid(),
+    from: 'client',
+    to: 'SERVER',
+    serviceName: 'test',
+    procedureName: 'test',
+    payload: {
+        msg: 'cool',
+        test: Math.random(),
+    },
+});
+describe('sending and receiving across websockets works', async () => {
     const server = http.createServer();
-    let wss;
-    beforeAll(async () => {
-        await onServerReady(server, port);
-        wss = await createWebSocketServer(server);
-    });
+    const port = await onServerReady(server);
+    const wss = await createWebSocketServer(server);
     afterAll(() => {
         wss.clients.forEach((socket) => {
             socket.close();
@@ -17,25 +24,52 @@ describe('sending and receiving across websockets works', () => {
         server.close();
     });
     test('basic send/receive', async () => {
-        let serverTransport;
-        wss.on('connection', (conn) => {
-            serverTransport = new WebSocketTransport(conn, 'SERVER');
-        });
-        const clientSoc = await createWebSocketClient(port);
-        const clientTransport = new WebSocketTransport(clientSoc, 'client');
-        const msg = {
-            msg: 'cool',
-            test: 123,
-        };
-        clientTransport.send({
-            id: '1',
-            from: 'client',
-            to: 'SERVER',
-            serviceName: 'test',
-            procedureName: 'test',
-            payload: msg,
+        const [clientTransport, serverTransport] = createWsTransports(port, wss);
+        const msg = getMsg();
+        clientTransport.send(msg);
+        return expect(waitForMessage(serverTransport, (recv) => recv.id === msg.id)).resolves.toStrictEqual(msg.payload);
+    });
+});
+describe('retry logic', async () => {
+    const server = http.createServer();
+    const port = await onServerReady(server);
+    const wss = await createWebSocketServer(server);
+    afterAll(() => {
+        wss.clients.forEach((socket) => {
+            socket.close();
         });
-        expect(serverTransport).toBeTruthy();
-        return expect(waitForMessage(serverTransport)).resolves.toStrictEqual(msg);
+        server.close();
+    });
+    // TODO: right now, we only test client-side disconnects, we probably
+    // need to also write tests for server-side crashes (but this involves clearing/restoring state)
+    // not going to worry about this rn but for future
+    test('ws transport is recreated after clean disconnect', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, wss);
+        const msg1 = getMsg();
+        const msg2 = getMsg();
+        clientTransport.send(msg1);
+        await expect(waitForMessage(serverTransport, (recv) => recv.id === msg1.id)).resolves.toStrictEqual(msg1.payload);
+        clientTransport.ws?.close();
+        clientTransport.send(msg2);
+        return expect(waitForMessage(serverTransport, (recv) => recv.id === msg2.id)).resolves.toStrictEqual(msg2.payload);
+    });
+    test('ws transport is recreated after unclean disconnect', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, wss);
+        const msg1 = getMsg();
+        const msg2 = getMsg();
+        clientTransport.send(msg1);
+        await expect(waitForMessage(serverTransport, (recv) => recv.id === msg1.id)).resolves.toStrictEqual(msg1.payload);
+        clientTransport.ws?.terminate();
+        clientTransport.send(msg2);
+        return expect(waitForMessage(serverTransport, (recv) => recv.id === msg2.id)).resolves.toStrictEqual(msg2.payload);
+    });
+    test('ws transport is not recreated after manually closing', async () => {
+        const [clientTransport, serverTransport] = createWsTransports(port, wss);
+        const msg1 = getMsg();
+        const msg2 = getMsg();
+        clientTransport.send(msg1);
+        await expect(waitForMessage(serverTransport, (recv) => recv.id === msg1.id)).resolves.toStrictEqual(msg1.payload);
+        clientTransport.close();
+        return expect(() => clientTransport.send(msg2)).toThrow(new Error('ws is destroyed, cant send'));
     });
 });

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@replit/river",
+  "sideEffects": false,
   "description": "It's like tRPC but... with JSON Schema Support, duplex streaming and support for service multiplexing. Transport agnostic!",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "index.js",
+  "types": "index.d.ts",
   "files": [
     "dist"
   ],
@@ -28,7 +29,8 @@
     "build": "tsc",
     "prepack": "npm run build",
     "release": "npm publish --access public",
-    "test": "vitest"
+    "test": "vitest",
+    "bench": "vitest bench"
   },
   "engines": {
     "node": ">=16"