@replit/river 0.10.10 → 0.10.12

package/README.md

@@ -89,6 +89,7 @@ In another file for the client (to create a separate entrypoint),
 import WebSocket from 'isomorphic-ws';
 import { WebSocketClientTransport } from '@replit/river/transport/ws/client';
 import { createClient } from '@replit/river';
+import type ServiceSurface from './server';
 
 const websocketUrl = `ws://localhost:3000`;
 const transport = new WebSocketClientTransport(
@@ -118,6 +119,24 @@ bindLogger(console.log);
 setLevel('info');
 ```
 
+To listen for connection status changes,
+
+```ts
+transport.addEventListener('connectionStatus', (evt) => {
+  if (evt.status === 'connect') {
+    // do something
+  } else if (evt.status === 'disconnect') {
+    // do something else
+  }
+});
+```
+
+> [!note] WebSocket connection behaviour
+> WebSocket is an idle protocol. This means that when the underlying connection drops, the WebSocket
+> may still think it is still connected (e.g. turning off the network via devtools).
+> You can use `window.addEventListener('online', ...);` and `window.addEventListener('offline', ...);` to
+> know if you need to recreate the transport.
+
 ### Further examples
 
 We've also provided an end-to-end testing environment using Next.js, and a simple backend connected

package/dist/{chunk-FTVAZZ6B.js → chunk-5IC5XMWK.js}

@@ -27,20 +27,28 @@ var WebSocketClientTransport = class extends Transport {
   reconnectPromises;
   tryReconnecting = true;
   /**
-   * Creates a new WebSocketTransport instance.
+   * Creates a new WebSocketClientTransport instance.
    * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
-   * @param clientId The ID of the client using the transport.
+   * @param sessionId The ID of the client using the transport. This should be unique per session.
+   * @param serverId The ID of the server this transport is connecting to.
    * @param providedOptions An optional object containing configuration options for the transport.
    */
-  constructor(wsGetter, clientId, serverId, providedOptions) {
+  constructor(wsGetter, sessionId, serverId, providedOptions) {
     const options = { ...defaultOptions, ...providedOptions };
-    super(options.codec, clientId);
+    super(options.codec, sessionId);
     this.wsGetter = wsGetter;
     this.serverId = serverId;
     this.options = options;
     this.reconnectPromises = /* @__PURE__ */ new Map();
     this.createNewConnection(this.serverId);
   }
+  reopen() {
+    if (this.state === "destroyed") {
+      throw new Error("cant reopen a destroyed connection");
+    }
+    this.state = "open";
+    this.createNewConnection(this.serverId);
+  }
   async createNewConnection(to, attempt = 0) {
     if (this.state === "destroyed") {
       throw new Error("cant reopen a destroyed connection");
@@ -55,23 +63,28 @@ var WebSocketClientTransport = class extends Transport {
       }
       reconnectPromise = new Promise(async (resolve) => {
         log?.info(`${this.clientId} -- establishing a new websocket to ${to}`);
-        const ws = await this.wsGetter(to);
-        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" });
+        try {
+          const ws = await this.wsGetter(to);
+          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" });
+          }
+          const onOpen = () => {
+            ws.removeEventListener("open", onOpen);
+            resolve({ ws });
+          };
+          const onClose = (evt) => {
+            ws.removeEventListener("close", onClose);
+            resolve({ err: evt.reason });
+          };
+          ws.addEventListener("open", onOpen);
+          ws.addEventListener("close", onClose);
+        } catch (e) {
+          const reason = e instanceof Error ? e.message : "unknown reason";
+          return resolve({ err: `couldn't get a new websocket: ${reason}` });
         }
-        const onOpen = () => {
-          ws.removeEventListener("open", onOpen);
-          resolve({ ws });
-        };
-        const onClose = (evt) => {
-          ws.removeEventListener("close", onClose);
-          resolve({ err: evt.reason });
-        };
-        ws.addEventListener("open", onOpen);
-        ws.addEventListener("close", onClose);
       });
       this.reconnectPromises.set(to, reconnectPromise);
     }

package/dist/transport/impls/ws/client.cjs

@@ -417,20 +417,28 @@ var WebSocketClientTransport = class extends Transport {
   reconnectPromises;
   tryReconnecting = true;
   /**
-   * Creates a new WebSocketTransport instance.
+   * Creates a new WebSocketClientTransport instance.
    * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
-   * @param clientId The ID of the client using the transport.
+   * @param sessionId The ID of the client using the transport. This should be unique per session.
+   * @param serverId The ID of the server this transport is connecting to.
    * @param providedOptions An optional object containing configuration options for the transport.
    */
-  constructor(wsGetter, clientId, serverId, providedOptions) {
+  constructor(wsGetter, sessionId, serverId, providedOptions) {
     const options = { ...defaultOptions, ...providedOptions };
-    super(options.codec, clientId);
+    super(options.codec, sessionId);
     this.wsGetter = wsGetter;
     this.serverId = serverId;
     this.options = options;
     this.reconnectPromises = /* @__PURE__ */ new Map();
     this.createNewConnection(this.serverId);
   }
+  reopen() {
+    if (this.state === "destroyed") {
+      throw new Error("cant reopen a destroyed connection");
+    }
+    this.state = "open";
+    this.createNewConnection(this.serverId);
+  }
   async createNewConnection(to, attempt = 0) {
     if (this.state === "destroyed") {
       throw new Error("cant reopen a destroyed connection");
@@ -445,23 +453,28 @@ var WebSocketClientTransport = class extends Transport {
       }
       reconnectPromise = new Promise(async (resolve) => {
         log?.info(`${this.clientId} -- establishing a new websocket to ${to}`);
-        const ws = await this.wsGetter(to);
-        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" });
+        try {
+          const ws = await this.wsGetter(to);
+          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" });
+          }
+          const onOpen = () => {
+            ws.removeEventListener("open", onOpen);
+            resolve({ ws });
+          };
+          const onClose = (evt) => {
+            ws.removeEventListener("close", onClose);
+            resolve({ err: evt.reason });
+          };
+          ws.addEventListener("open", onOpen);
+          ws.addEventListener("close", onClose);
+        } catch (e) {
+          const reason = e instanceof Error ? e.message : "unknown reason";
+          return resolve({ err: `couldn't get a new websocket: ${reason}` });
         }
-        const onOpen = () => {
-          ws.removeEventListener("open", onOpen);
-          resolve({ ws });
-        };
-        const onClose = (evt) => {
-          ws.removeEventListener("close", onClose);
-          resolve({ err: evt.reason });
-        };
-        ws.addEventListener("open", onOpen);
-        ws.addEventListener("close", onClose);
       });
       this.reconnectPromises.set(to, reconnectPromise);
     }

package/dist/transport/impls/ws/client.d.cts

@@ -29,12 +29,14 @@ declare class WebSocketClientTransport extends Transport<WebSocketConnection> {
     reconnectPromises: Map<TransportClientId, Promise<WebSocketResult>>;
     tryReconnecting: boolean;
     /**
-     * Creates a new WebSocketTransport instance.
+     * Creates a new WebSocketClientTransport instance.
      * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
-     * @param clientId The ID of the client using the transport.
+     * @param sessionId The ID of the client using the transport. This should be unique per session.
+     * @param serverId The ID of the server this transport is connecting to.
      * @param providedOptions An optional object containing configuration options for the transport.
      */
-    constructor(wsGetter: () => Promise<WebSocket>, clientId: TransportClientId, serverId: TransportClientId, providedOptions?: Partial<Options>);
+    constructor(wsGetter: () => Promise<WebSocket>, sessionId: TransportClientId, serverId: TransportClientId, providedOptions?: Partial<Options>);
+    reopen(): void;
     createNewConnection(to: string, attempt?: number): Promise<void>;
     close(): Promise<void>;
     destroy(): Promise<void>;

package/dist/transport/impls/ws/client.d.ts

@@ -29,12 +29,14 @@ declare class WebSocketClientTransport extends Transport<WebSocketConnection> {
     reconnectPromises: Map<TransportClientId, Promise<WebSocketResult>>;
     tryReconnecting: boolean;
     /**
-     * Creates a new WebSocketTransport instance.
+     * Creates a new WebSocketClientTransport instance.
      * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
-     * @param clientId The ID of the client using the transport.
+     * @param sessionId The ID of the client using the transport. This should be unique per session.
+     * @param serverId The ID of the server this transport is connecting to.
      * @param providedOptions An optional object containing configuration options for the transport.
      */
-    constructor(wsGetter: () => Promise<WebSocket>, clientId: TransportClientId, serverId: TransportClientId, providedOptions?: Partial<Options>);
+    constructor(wsGetter: () => Promise<WebSocket>, sessionId: TransportClientId, serverId: TransportClientId, providedOptions?: Partial<Options>);
+    reopen(): void;
     createNewConnection(to: string, attempt?: number): Promise<void>;
     close(): Promise<void>;
     destroy(): Promise<void>;

package/dist/transport/impls/ws/client.js

@@ -1,6 +1,6 @@
 import {
   WebSocketClientTransport
-} from "../../../chunk-FTVAZZ6B.js";
+} from "../../../chunk-5IC5XMWK.js";
 import "../../../chunk-L7D75G4K.js";
 import "../../../chunk-R6H2BIMC.js";
 import "../../../chunk-LQXPKF3A.js";

package/dist/transport/index.d.cts

@@ -205,6 +205,10 @@ declare abstract class Transport<ConnType extends Connection> {
      * The downstream implementation needs to implement this. If the downstream
      * transport cannot make new outgoing connections (e.g. a server transport),
      * it is ok to log an error and return.
+     *
+     * Consumers of river should never need to call this directly.
+     * Instead, look for a `reopen` method on the transport.
+     *
      * @param to The client ID of the node to connect to.
      * @returns The new connection object.
      */

package/dist/transport/index.d.ts

@@ -205,6 +205,10 @@ declare abstract class Transport<ConnType extends Connection> {
      * The downstream implementation needs to implement this. If the downstream
      * transport cannot make new outgoing connections (e.g. a server transport),
      * it is ok to log an error and return.
+     *
+     * Consumers of river should never need to call this directly.
+     * Instead, look for a `reopen` method on the transport.
+     *
      * @param to The client ID of the node to connect to.
      * @returns The new connection object.
      */

package/dist/util/testHelpers.cjs

@@ -454,20 +454,28 @@ var WebSocketClientTransport = class extends Transport {
   reconnectPromises;
   tryReconnecting = true;
   /**
-   * Creates a new WebSocketTransport instance.
+   * Creates a new WebSocketClientTransport instance.
    * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
-   * @param clientId The ID of the client using the transport.
+   * @param sessionId The ID of the client using the transport. This should be unique per session.
+   * @param serverId The ID of the server this transport is connecting to.
    * @param providedOptions An optional object containing configuration options for the transport.
    */
-  constructor(wsGetter, clientId, serverId, providedOptions) {
+  constructor(wsGetter, sessionId, serverId, providedOptions) {
     const options = { ...defaultOptions, ...providedOptions };
-    super(options.codec, clientId);
+    super(options.codec, sessionId);
     this.wsGetter = wsGetter;
     this.serverId = serverId;
     this.options = options;
     this.reconnectPromises = /* @__PURE__ */ new Map();
     this.createNewConnection(this.serverId);
   }
+  reopen() {
+    if (this.state === "destroyed") {
+      throw new Error("cant reopen a destroyed connection");
+    }
+    this.state = "open";
+    this.createNewConnection(this.serverId);
+  }
   async createNewConnection(to, attempt = 0) {
     if (this.state === "destroyed") {
       throw new Error("cant reopen a destroyed connection");
@@ -482,23 +490,28 @@ var WebSocketClientTransport = class extends Transport {
       }
       reconnectPromise = new Promise(async (resolve) => {
         log?.info(`${this.clientId} -- establishing a new websocket to ${to}`);
-        const ws = await this.wsGetter(to);
-        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" });
+        try {
+          const ws = await this.wsGetter(to);
+          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" });
+          }
+          const onOpen = () => {
+            ws.removeEventListener("open", onOpen);
+            resolve({ ws });
+          };
+          const onClose = (evt) => {
+            ws.removeEventListener("close", onClose);
+            resolve({ err: evt.reason });
+          };
+          ws.addEventListener("open", onOpen);
+          ws.addEventListener("close", onClose);
+        } catch (e) {
+          const reason = e instanceof Error ? e.message : "unknown reason";
+          return resolve({ err: `couldn't get a new websocket: ${reason}` });
         }
-        const onOpen = () => {
-          ws.removeEventListener("open", onOpen);
-          resolve({ ws });
-        };
-        const onClose = (evt) => {
-          ws.removeEventListener("close", onClose);
-          resolve({ err: evt.reason });
-        };
-        ws.addEventListener("open", onOpen);
-        ws.addEventListener("close", onClose);
       });
       this.reconnectPromises.set(to, reconnectPromise);
     }

package/dist/util/testHelpers.js

@@ -4,7 +4,7 @@ import {
 } from "../chunk-3JGVFWKQ.js";
 import {
   WebSocketClientTransport
-} from "../chunk-FTVAZZ6B.js";
+} from "../chunk-5IC5XMWK.js";
 import {
   WebSocketServerTransport
 } from "../chunk-PJ2EUO7O.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@replit/river",
   "description": "It's like tRPC but... with JSON Schema Support, duplex streaming and support for service multiplexing. Transport agnostic!",
-  "version": "0.10.10",
+  "version": "0.10.12",
   "type": "module",
   "exports": {
     ".": {
@@ -63,11 +63,11 @@
   },
   "devDependencies": {
     "@types/ws": "^8.5.5",
-    "@vitest/ui": "^1.1.0",
+    "@vitest/ui": "^1.2.1",
     "prettier": "^3.0.0",
     "tsup": "^7.2.0",
     "typescript": "^5.2.2",
-    "vitest": "^1.1.0"
+    "vitest": "^1.2.1"
   },
   "scripts": {
     "check": "tsc --noEmit && npx prettier . --check",