@replit/river 0.10.10 → 0.10.11

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-KW5VFJRN.js}

@@ -27,14 +27,15 @@ 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;
@@ -55,23 +56,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 });
+        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}` });
         }
-        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);
       });
       this.reconnectPromises.set(to, reconnectPromise);
     }

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

@@ -417,14 +417,15 @@ 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;
@@ -445,23 +446,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 });
+        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}` });
         }
-        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);
       });
       this.reconnectPromises.set(to, reconnectPromise);
     }

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

@@ -29,12 +29,13 @@ 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>);
     createNewConnection(to: string, attempt?: number): Promise<void>;
     close(): Promise<void>;
     destroy(): Promise<void>;

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

@@ -29,12 +29,13 @@ 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>);
     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-KW5VFJRN.js";
 import "../../../chunk-L7D75G4K.js";
 import "../../../chunk-R6H2BIMC.js";
 import "../../../chunk-LQXPKF3A.js";

package/dist/util/testHelpers.cjs

@@ -454,14 +454,15 @@ 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;
@@ -482,23 +483,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-KW5VFJRN.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.11",
   "type": "module",
   "exports": {
     ".": {