cojson-transport-ws 0.9.23 → 0.10.1

package/src/index.ts

@@ -1,239 +1,2 @@
-import {
-  DisconnectedError,
-  Peer,
-  PingTimeoutError,
-  SyncMessage,
-  cojsonInternals,
-  logger,
-} from "cojson";
-import { BatchedOutgoingMessages } from "./BatchedOutgoingMessages.js";
-import { deserializeMessages, getErrorMessage } from "./serialization.js";
-import { AnyWebSocket } from "./types.js";
-
-export const BUFFER_LIMIT = 100_000;
-export const BUFFER_LIMIT_POLLING_INTERVAL = 10;
-
-export type CreateWebSocketPeerOpts = {
-  id: string;
-  websocket: AnyWebSocket;
-  role: Peer["role"];
-  expectPings?: boolean;
-  batchingByDefault?: boolean;
-  deletePeerStateOnClose?: boolean;
-  onClose?: () => void;
-  onSuccess?: () => void;
-};
-
-function createPingTimeoutListener(enabled: boolean, callback: () => void) {
-  if (!enabled) {
-    return {
-      reset() {},
-      clear() {},
-    };
-  }
-
-  let pingTimeout: ReturnType<typeof setTimeout> | null = null;
-
-  return {
-    reset() {
-      pingTimeout && clearTimeout(pingTimeout);
-      pingTimeout = setTimeout(() => {
-        callback();
-      }, 10_000);
-    },
-    clear() {
-      pingTimeout && clearTimeout(pingTimeout);
-    },
-  };
-}
-
-function waitForWebSocketOpen(websocket: AnyWebSocket) {
-  return new Promise<void>((resolve) => {
-    if (websocket.readyState === 1) {
-      resolve();
-    } else {
-      websocket.addEventListener("open", resolve, { once: true });
-    }
-  });
-}
-
-function createOutgoingMessagesManager(
-  websocket: AnyWebSocket,
-  batchingByDefault: boolean,
-) {
-  let closed = false;
-  const outgoingMessages = new BatchedOutgoingMessages((messages) => {
-    if (websocket.readyState === 1) {
-      websocket.send(messages);
-    }
-  });
-
-  let batchingEnabled = batchingByDefault;
-
-  async function sendMessage(msg: SyncMessage) {
-    if (closed) {
-      return Promise.reject(new Error("WebSocket closed"));
-    }
-
-    if (websocket.readyState !== 1) {
-      await waitForWebSocketOpen(websocket);
-    }
-
-    while (
-      websocket.bufferedAmount > BUFFER_LIMIT &&
-      websocket.readyState === 1
-    ) {
-      await new Promise<void>((resolve) =>
-        setTimeout(resolve, BUFFER_LIMIT_POLLING_INTERVAL),
-      );
-    }
-
-    if (websocket.readyState !== 1) {
-      return;
-    }
-
-    if (!batchingEnabled) {
-      websocket.send(JSON.stringify(msg));
-    } else {
-      outgoingMessages.push(msg);
-    }
-  }
-
-  return {
-    sendMessage,
-    setBatchingEnabled(enabled: boolean) {
-      batchingEnabled = enabled;
-    },
-    close() {
-      closed = true;
-      outgoingMessages.close();
-    },
-  };
-}
-
-function createClosedEventEmitter(callback = () => {}) {
-  let disconnected = false;
-
-  return () => {
-    if (disconnected) return;
-    disconnected = true;
-    callback();
-  };
-}
-
-export function createWebSocketPeer({
-  id,
-  websocket,
-  role,
-  expectPings = true,
-  batchingByDefault = true,
-  deletePeerStateOnClose = false,
-  onSuccess,
-  onClose,
-}: CreateWebSocketPeerOpts): Peer {
-  const incoming = new cojsonInternals.Channel<
-    SyncMessage | DisconnectedError | PingTimeoutError
-  >();
-  const emitClosedEvent = createClosedEventEmitter(onClose);
-
-  function handleClose() {
-    incoming
-      .push("Disconnected")
-      .catch((e) => logger.error("Error while pushing disconnect msg", e));
-    emitClosedEvent();
-  }
-
-  websocket.addEventListener("close", handleClose);
-  websocket.addEventListener("error" as any, (err) => {
-    logger.warn(err.message);
-
-    if (err.message.includes("ECONNREFUSED")) {
-      websocket.close();
-    }
-  });
-
-  const pingTimeout = createPingTimeoutListener(expectPings, () => {
-    incoming
-      .push("PingTimeout")
-      .catch((e) => logger.error("Error while pushing ping timeout", e));
-    emitClosedEvent();
-  });
-
-  const outgoingMessages = createOutgoingMessagesManager(
-    websocket,
-    batchingByDefault,
-  );
-  let isFirstMessage = true;
-
-  function handleIncomingMsg(event: { data: unknown }) {
-    if (event.data === "") {
-      return;
-    }
-
-    const result = deserializeMessages(event.data);
-
-    if (!result.ok) {
-      logger.warn(
-        "Error while deserializing messages: " + getErrorMessage(result.error),
-      );
-      return;
-    }
-
-    if (isFirstMessage) {
-      // The only way to know that the connection has been correctly established with our sync server
-      // is to track that we got a message from the server.
-      onSuccess?.();
-      isFirstMessage = false;
-    }
-
-    const { messages } = result;
-
-    if (messages.length > 1) {
-      // If more than one message is received, the other peer supports batching
-      outgoingMessages.setBatchingEnabled(true);
-    }
-
-    pingTimeout.reset();
-
-    for (const msg of messages) {
-      if (msg && "action" in msg) {
-        incoming
-          .push(msg)
-          .catch((e) => logger.error("Error while pushing incoming msg", e));
-      }
-    }
-  }
-
-  websocket.addEventListener("message", handleIncomingMsg);
-
-  return {
-    id,
-    incoming,
-    outgoing: {
-      push: outgoingMessages.sendMessage,
-      close() {
-        outgoingMessages.close();
-
-        websocket.removeEventListener("message", handleIncomingMsg);
-        websocket.removeEventListener("close", handleClose);
-        pingTimeout.clear();
-        emitClosedEvent();
-
-        if (websocket.readyState === 0) {
-          websocket.addEventListener(
-            "open",
-            function handleClose() {
-              websocket.close();
-            },
-            { once: true },
-          );
-        } else if (websocket.readyState == 1) {
-          websocket.close();
-        }
-      },
-    },
-    role,
-    crashOnClose: false,
-    deletePeerStateOnClose,
-  };
-}
+export * from "./createWebSocketPeer.js";
+export * from "./WebSocketPeerWithReconnection.js";

package/src/tests/BatchedOutgoingMessages.test.ts

@@ -1,5 +1,5 @@
 import { SyncMessage } from "cojson";
-import { CoValueKnownState } from "cojson/src/sync.js";
+import { CojsonInternalTypes } from "cojson";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import {
   BatchedOutgoingMessages,
@@ -58,7 +58,7 @@ describe("BatchedOutgoingMessages", () => {
       sessions: {
         // Add a large payload to exceed MAX_OUTGOING_MESSAGES_CHUNK_BYTES
         payload: "x".repeat(MAX_OUTGOING_MESSAGES_CHUNK_BYTES),
-      } as CoValueKnownState["sessions"],
+      } as CojsonInternalTypes.CoValueKnownState["sessions"],
     };
 
     batchedMessages.push(largeMessage);
@@ -82,7 +82,7 @@ describe("BatchedOutgoingMessages", () => {
       sessions: {
         // Add a large payload to exceed MAX_OUTGOING_MESSAGES_CHUNK_BYTES
         payload: "x".repeat(MAX_OUTGOING_MESSAGES_CHUNK_BYTES),
-      } as CoValueKnownState["sessions"],
+      } as CojsonInternalTypes.CoValueKnownState["sessions"],
     };
 
     batchedMessages.push(smallMessage);

package/src/tests/WebSocketPeerWithReconnection.test.ts

@@ -0,0 +1,143 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { WebSocketPeerWithReconnection } from "../WebSocketPeerWithReconnection";
+import { startSyncServer } from "./syncServer";
+import { waitFor } from "./utils";
+
+describe("WebSocketPeerWithReconnection", () => {
+  let server: any;
+  let syncServerUrl: string;
+
+  beforeEach(async () => {
+    const result = await startSyncServer();
+    server = result;
+    syncServerUrl = result.syncServer;
+  });
+
+  afterEach(() => {
+    server.close();
+  });
+
+  test("should connect successfully to sync server", async () => {
+    const addPeer = vi.fn();
+    const removePeer = vi.fn();
+
+    const peer = new WebSocketPeerWithReconnection({
+      peer: syncServerUrl,
+      reconnectionTimeout: 100,
+      addPeer,
+      removePeer,
+    });
+
+    peer.enable();
+
+    // Wait for connection to establish
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    expect(addPeer).toHaveBeenCalledTimes(1);
+    expect(removePeer).not.toHaveBeenCalled();
+
+    peer.disable();
+  });
+
+  test("should attempt reconnection when server disconnects", async () => {
+    const addPeer = vi.fn();
+    const removePeer = vi.fn();
+
+    const peer = new WebSocketPeerWithReconnection({
+      peer: syncServerUrl,
+      reconnectionTimeout: 100,
+      addPeer,
+      removePeer,
+    });
+
+    peer.enable();
+
+    // Wait for initial connection
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    addPeer.mockClear();
+
+    // Close server to simulate disconnect
+    server.close();
+
+    // Wait for disconnect to be detected
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    expect(removePeer).toHaveBeenCalled();
+    expect(peer.reconnectionAttempts).toBeGreaterThan(0);
+
+    // Start server again
+    server = await startSyncServer(server.port);
+
+    // Wait for reconnection
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(addPeer).toHaveBeenCalled();
+
+    peer.disable();
+  });
+
+  test("should stop reconnection attempts when disabled", async () => {
+    const addPeer = vi.fn();
+    const removePeer = vi.fn();
+
+    const peer = new WebSocketPeerWithReconnection({
+      peer: syncServerUrl,
+      reconnectionTimeout: 100,
+      addPeer,
+      removePeer,
+    });
+
+    peer.enable();
+
+    // Wait for initial connection
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Close server and disable peer
+    server.close();
+    peer.disable();
+
+    // Wait to ensure no reconnection attempts
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(addPeer).toHaveBeenCalledTimes(1);
+    expect(removePeer).toHaveBeenCalledTimes(1);
+    expect(peer.reconnectionAttempts).toBe(0);
+  });
+
+  test("should reset reconnection attempts when connection is successful", async () => {
+    const addPeer = vi.fn();
+    const removePeer = vi.fn();
+
+    const peer = new WebSocketPeerWithReconnection({
+      peer: syncServerUrl,
+      reconnectionTimeout: 10,
+      addPeer,
+      removePeer,
+    });
+
+    peer.enable();
+
+    // Wait for initial connection
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Close server to trigger reconnection attempts
+    server.close();
+
+    // Wait for some reconnection attempts
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    const previousAttempts = peer.reconnectionAttempts;
+    expect(previousAttempts).toBeGreaterThan(0);
+
+    // Start server again
+    server = await startSyncServer(server.port);
+
+    // Wait for successful reconnection
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    await waitFor(() => expect(peer.reconnectionAttempts).toBe(0));
+
+    peer.disable();
+  });
+});

package/src/tests/createWebSocketPeer.test.ts

@@ -7,7 +7,7 @@ import {
   BUFFER_LIMIT_POLLING_INTERVAL,
   CreateWebSocketPeerOpts,
   createWebSocketPeer,
-} from "../index.js";
+} from "../createWebSocketPeer.js";
 import { AnyWebSocket } from "../types.js";
 
 function setup(opts: Partial<CreateWebSocketPeerOpts> = {}) {

package/src/tests/integration.test.ts

@@ -1,7 +1,8 @@
-import { ControlledAgent, LocalNode, WasmCrypto } from "cojson";
+import { ControlledAgent, LocalNode } from "cojson";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { WebSocket } from "ws";
-import { createWebSocketPeer } from "../index";
+import { createWebSocketPeer } from "../createWebSocketPeer";
 import { startSyncServer } from "./syncServer";
 
 describe("WebSocket Peer Integration", () => {
@@ -86,7 +87,6 @@ describe("WebSocket Peer Integration", () => {
 
     // Wait for sync
     await map.core.waitForSync();
-    console.log("synced");
 
     // Verify data reached the server
     const serverNode = server.localNode;

package/src/tests/syncServer.ts

@@ -1,7 +1,8 @@
 import { createServer } from "http";
-import { ControlledAgent, LocalNode, WasmCrypto } from "cojson";
+import { ControlledAgent, LocalNode } from "cojson";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { WebSocket, WebSocketServer } from "ws";
-import { createWebSocketPeer } from "../index";
+import { createWebSocketPeer } from "../createWebSocketPeer";
 
 export const startSyncServer = async (port?: number) => {
   const crypto = await WasmCrypto.create();

package/src/tests/utils.ts

@@ -0,0 +1,27 @@
+export function waitFor(callback: () => boolean | void) {
+  return new Promise<void>((resolve, reject) => {
+    const checkPassed = () => {
+      try {
+        return { ok: callback(), error: null };
+      } catch (error) {
+        return { ok: false, error };
+      }
+    };
+
+    let retries = 0;
+
+    const interval = setInterval(() => {
+      const { ok, error } = checkPassed();
+
+      if (ok !== false) {
+        clearInterval(interval);
+        resolve();
+      }
+
+      if (++retries > 10) {
+        clearInterval(interval);
+        reject(error);
+      }
+    }, 100);
+  });
+}