@automerge/automerge-repo-network-websocket 1.0.9 → 1.0.10

package/dist/BrowserWebSocketClientAdapter.d.ts

@@ -8,6 +8,7 @@ declare abstract class WebSocketNetworkAdapter extends NetworkAdapter {
 export declare class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
     #private;
     timerId?: ReturnType<typeof setTimeout>;
+    remotePeerId?: PeerId;
     url: string;
     constructor(url: string);
     connect(peerId: PeerId): void;

package/dist/BrowserWebSocketClientAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserWebSocketClientAdapter.d.ts","sourceRoot":"","sources":["../src/BrowserWebSocketClientAdapter.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,EAAQ,MAAM,2BAA2B,CAAA;AACxE,OAAO,SAAS,MAAM,eAAe,CAAA;AAIrC,OAAO,EACL,iBAAiB,EAGlB,MAAM,eAAe,CAAA;AAMtB,uBAAe,uBAAwB,SAAQ,cAAc;IAC3D,MAAM,CAAC,EAAE,SAAS,CAAA;CACnB;AAED,qBAAa,6BAA8B,SAAQ,uBAAuB;;IAGxE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;IAGvC,GAAG,EAAE,MAAM,CAAA;gBAEC,GAAG,EAAE,MAAM;IAKvB,OAAO,CAAC,MAAM,EAAE,MAAM;IAkCtB,MAAM,aAKL;IAGD,OAAO,aAON;IAED,SAAS,UAAW,sBAAsB,UAEzC;IAED,IAAI;IAWJ,UAAU;IAOV,IAAI,CAAC,OAAO,EAAE,iBAAiB;IAwB/B,kBAAkB,CAAC,MAAM,EAAE,MAAM;IAajC,cAAc,CAAC,OAAO,EAAE,UAAU;CA6BnC"}
+{"version":3,"file":"BrowserWebSocketClientAdapter.d.ts","sourceRoot":"","sources":["../src/BrowserWebSocketClientAdapter.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,EAAQ,MAAM,2BAA2B,CAAA;AACxE,OAAO,SAAS,MAAM,eAAe,CAAA;AAIrC,OAAO,EACL,iBAAiB,EAGlB,MAAM,eAAe,CAAA;AAMtB,uBAAe,uBAAwB,SAAQ,cAAc;IAC3D,MAAM,CAAC,EAAE,SAAS,CAAA;CACnB;AAED,qBAAa,6BAA8B,SAAQ,uBAAuB;;IAGxE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;IACvC,YAAY,CAAC,EAAE,MAAM,CAAA;IAGrB,GAAG,EAAE,MAAM,CAAA;gBAEC,GAAG,EAAE,MAAM;IAKvB,OAAO,CAAC,MAAM,EAAE,MAAM;IAkCtB,MAAM,aAKL;IAGD,OAAO,aAYN;IAED,SAAS,UAAW,sBAAsB,UAEzC;IAED,IAAI;IAWJ,UAAU;IAOV,IAAI,CAAC,OAAO,EAAE,iBAAiB;IAwB/B,kBAAkB,CAAC,MAAM,EAAE,MAAM;IAcjC,cAAc,CAAC,OAAO,EAAE,UAAU;CA6BnC"}

package/dist/BrowserWebSocketClientAdapter.js

@@ -11,6 +11,7 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
     // Type trickery required for platform independence,
     // see https://stackoverflow.com/questions/45802988/typescript-use-correct-version-of-settimeout-node-vs-window
     timerId;
+    remotePeerId; // this adapter only connects to one remote client at a time
     #startupComplete = false;
     url;
     constructor(url) {
@@ -54,6 +55,9 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
     // When a socket closes, or disconnects, remove it from the array.
     onClose = () => {
         log(`${this.url}: close`);
+        if (this.remotePeerId) {
+            this.emit("peer-disconnected", { peerId: this.remotePeerId });
+        }
         if (!this.timerId) {
             if (this.peerId) {
                 this.connect(this.peerId);
@@ -106,6 +110,7 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
             this.#startupComplete = true;
             this.emit("ready", { network: this });
         }
+        this.remotePeerId = peerId;
         this.emit("peer-candidate", { peerId });
     }
     receiveMessage(message) {

package/dist/NodeWSServerAdapter.js

@@ -50,7 +50,7 @@ export class NodeWSServerAdapter extends NetworkAdapter {
                 socket.isAlive = false;
                 socket.ping();
             });
-        }, 30000);
+        }, 5000);
     }
     disconnect() {
         // throw new Error("The server doesn't join channels.")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automerge/automerge-repo-network-websocket",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "isomorphic node/browser Websocket network adapter for Automerge Repo",
   "peerDependencies": {
     "@automerge/automerge": "^2.1.0"
@@ -16,7 +16,7 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@automerge/automerge-repo": "^1.0.9",
+    "@automerge/automerge-repo": "^1.0.10",
     "cbor-x": "^1.3.0",
     "eventemitter3": "^5.0.1",
     "isomorphic-ws": "^5.0.0",
@@ -33,5 +33,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c277a6e8546cdd14236070d033ca62db68dfdeb3"
+  "gitHead": "a79cfa659547b7f4a12987bbbee0f4f2f7f219f4"
 }

package/src/BrowserWebSocketClientAdapter.ts

@@ -21,6 +21,7 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
   // Type trickery required for platform independence,
   // see https://stackoverflow.com/questions/45802988/typescript-use-correct-version-of-settimeout-node-vs-window
   timerId?: ReturnType<typeof setTimeout>
+  remotePeerId?: PeerId // this adapter only connects to one remote client at a time
   #startupComplete: boolean = false
 
   url: string
@@ -74,6 +75,11 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
   // When a socket closes, or disconnects, remove it from the array.
   onClose = () => {
     log(`${this.url}: close`)
+
+    if (this.remotePeerId) {
+      this.emit("peer-disconnected", { peerId: this.remotePeerId })
+    }
+
     if (!this.timerId) {
       if (this.peerId) {
         this.connect(this.peerId)
@@ -137,6 +143,7 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
       this.#startupComplete = true
       this.emit("ready", { network: this })
     }
+    this.remotePeerId = peerId
     this.emit("peer-candidate", { peerId })
   }
 

package/src/NodeWSServerAdapter.ts

@@ -75,7 +75,7 @@ export class NodeWSServerAdapter extends NetworkAdapter {
         socket.isAlive = false
         socket.ping()
       })
-    }, 30000)
+    }, 5000)
   }
 
   disconnect() {

package/test/Websocket.test.ts

@@ -1,39 +1,39 @@
-import { runAdapterTests } from "../../automerge-repo/src/helpers/tests/network-adapter-tests.js"
-import { BrowserWebSocketClientAdapter } from "../src/BrowserWebSocketClientAdapter.js"
-import { NodeWSServerAdapter } from "../src/NodeWSServerAdapter.js"
-import { startServer } from "./utilities/WebSockets.js"
-import * as CBOR from "cbor-x"
-import WebSocket, { AddressInfo } from "ws"
-import assert from "assert"
 import { PeerId, Repo } from "@automerge/automerge-repo"
+import assert from "assert"
+import * as CBOR from "cbor-x"
 import { once } from "events"
+import http from "http"
 import { describe, it } from "vitest"
+import WebSocket, { AddressInfo } from "ws"
+import { runAdapterTests } from "../../automerge-repo/src/helpers/tests/network-adapter-tests.js"
+import { BrowserWebSocketClientAdapter } from "../src/BrowserWebSocketClientAdapter.js"
+import { NodeWSServerAdapter } from "../src/NodeWSServerAdapter.js"
 
-describe("Websocket adapters", async () => {
-  let port = 8080
+describe("Websocket adapters", () => {
+  const setup = async (clientCount = 1) => {
+    const server = http.createServer()
+    const socket = new WebSocket.Server({ server })
 
-  runAdapterTests(async () => {
-    let socket: WebSocket.Server | undefined = undefined
-    let server: any
-
-    while (socket === undefined) {
-      try {
-        ;({ socket, server } = await startServer(port))
-      } catch (e: any) {
-        if (e.code === "EADDRINUSE") {
-          port++
-        } else {
-          throw e
-        }
-      }
-    }
+    await new Promise<void>(resolve => server.listen(0, resolve))
+    const { port } = server.address() as AddressInfo
+    const serverUrl = `ws://localhost:${port}`
 
-    const serverAdapter = new NodeWSServerAdapter(socket)
+    const clients = [] as BrowserWebSocketClientAdapter[]
+    for (let i = 0; i < clientCount; i++) {
+      clients.push(new BrowserWebSocketClientAdapter(serverUrl))
+    }
 
-    const serverUrl = `ws://localhost:${port}`
+    return { socket, server, port, serverUrl, clients }
+  }
 
-    const aliceAdapter = new BrowserWebSocketClientAdapter(serverUrl)
-    const bobAdapter = new BrowserWebSocketClientAdapter(serverUrl)
+  // run adapter acceptance tests
+  runAdapterTests(async () => {
+    const {
+      clients: [aliceAdapter, bobAdapter],
+      socket,
+      server,
+    } = await setup(2)
+    const serverAdapter = new NodeWSServerAdapter(socket)
 
     const teardown = () => {
       server.close()
@@ -41,140 +41,159 @@ describe("Websocket adapters", async () => {
 
     return { adapters: [aliceAdapter, serverAdapter, bobAdapter], teardown }
   })
-})
 
-describe("The BrowserWebSocketClientAdapter", () => {
-  it("should advertise the protocol versions it supports in its join message", async () => {
-    const { socket, server } = await startServer(0)
-    let port = (server.address()!! as AddressInfo).port
-    const serverUrl = `ws://localhost:${port}`
-    const helloPromise = firstMessage(socket)
+  describe("BrowserWebSocketClientAdapter", () => {
+    const firstMessage = async (socket: WebSocket.Server<any>) =>
+      new Promise((resolve, reject) => {
+        socket.once("connection", ws => {
+          ws.once("message", (message: any) => resolve(message))
+          ws.once("error", (error: any) => reject(error))
+        })
+        socket.once("error", error => reject(error))
+      })
 
-    const client = new BrowserWebSocketClientAdapter(serverUrl)
-    const repo = new Repo({ network: [client], peerId: "browser" as PeerId })
+    it("should advertise the protocol versions it supports in its join message", async () => {
+      const {
+        socket,
+        clients: [browser],
+      } = await setup()
 
-    const hello = await helloPromise
+      const helloPromise = firstMessage(socket)
 
-    const message = CBOR.decode(hello as Uint8Array)
-    assert.deepEqual(message, {
-      type: "join",
-      senderId: "browser",
-      supportedProtocolVersions: ["1"],
-    })
-  })
-})
+      const _repo = new Repo({
+        network: [browser],
+        peerId: "browser" as PeerId,
+      })
 
-describe("The NodeWSServerAdapter", () => {
-  it("should send the negotiated protocol version in its hello message", async () => {
-    const response = await serverHelloGivenClientHello({
-      type: "join",
-      senderId: "browser",
-      supportedProtocolVersions: ["1"],
-    })
-    assert.deepEqual<any>(response, {
-      type: "peer",
-      senderId: "server",
-      targetId: "browser",
-      selectedProtocolVersion: "1",
+      const encodedMessage = await helloPromise
+      const message = CBOR.decode(encodedMessage as Uint8Array)
+      assert.deepEqual(message, {
+        type: "join",
+        senderId: "browser",
+        supportedProtocolVersions: ["1"],
+      })
     })
-  })
 
-  it("should return an error message if the protocol version is not supported", async () => {
-    const response = await serverHelloGivenClientHello({
-      type: "join",
-      senderId: "browser",
-      supportedProtocolVersions: ["fake"],
+    it.skip("should announce disconnections", async () => {
+      const {
+        server,
+        socket,
+        clients: [browserAdapter],
+      } = await setup()
+
+      const _browserRepo = new Repo({
+        network: [browserAdapter],
+        peerId: "browser" as PeerId,
+      })
+
+      const serverAdapter = new NodeWSServerAdapter(socket)
+      const _serverRepo = new Repo({
+        network: [serverAdapter],
+        peerId: "server" as PeerId,
+      })
+
+      const disconnectPromise = new Promise<void>(resolve => {
+        browserAdapter.on("peer-disconnected", () => resolve())
+      })
+
+      server.close()
+      await disconnectPromise
     })
-    assert.deepEqual<any>(response, {
-      type: "error",
-      senderId: "server",
-      targetId: "browser",
-      message: "unsupported protocol version",
+
+    it("should correctly clear event handlers on reconnect", async () => {
+      // This reproduces an issue where the BrowserWebSocketClientAdapter.connect
+      // call registered event handlers on the websocket but didn't clear them
+      // up again on a second call to connect. This combined with the reconnect
+      // timer to produce the following sequence of events:
+      //
+      // - first call to connect creates a socket and registers an "open"
+      //   handler. The "open" handler will attempt to send a join message
+      // - The connection is slow, so the reconnect timer fires before "open",
+      //   the reconnect timer calls connect again. this.socket is now a new socket
+      // - The other end replies to the first socket, "open"
+      // - The original "open" handler attempts to send a message, but on the new
+      //   socket (because it uses `this.socket`), which isn't open yet, so we get an
+      //   error that the socket is not ready
+      const {
+        clients: [browser],
+      } = await setup()
+
+      const peerId = "testclient" as PeerId
+      browser.connect(peerId)
+
+      // simulate the reconnect timer firing before the other end has responded
+      // (which works here because we haven't yielded to the event loop yet so
+      // the server, which is on the same event loop as us, can't respond)
+      browser.connect(peerId)
+
+      // Now yield, so the server responds on the first socket, if the listeners
+      // are cleaned up correctly we shouldn't throw
+      await pause(1)
     })
   })
 
-  it("should respond with protocol v1 if no protocol version is specified", async () => {
-    const response = await serverHelloGivenClientHello({
-      type: "join",
-      senderId: "browser",
-    })
-    assert.deepEqual<any>(response, {
-      type: "peer",
-      senderId: "server",
-      targetId: "browser",
-      selectedProtocolVersion: "1",
+  describe("NodeWSServerAdapter", () => {
+    const serverResponse = async (clientHello: Object) => {
+      const { socket, serverUrl } = await setup(0)
+      const server = new NodeWSServerAdapter(socket)
+      const _serverRepo = new Repo({
+        network: [server],
+        peerId: "server" as PeerId,
+      })
+
+      const clientSocket = new WebSocket(serverUrl)
+      await once(clientSocket, "open")
+      const serverHelloPromise = once(clientSocket, "message")
+
+      clientSocket.send(CBOR.encode(clientHello))
+
+      const serverHello = await serverHelloPromise
+      const message = CBOR.decode(serverHello[0] as Uint8Array)
+      return message
+    }
+
+    it("should send the negotiated protocol version in its hello message", async () => {
+      const response = await serverResponse({
+        type: "join",
+        senderId: "browser",
+        supportedProtocolVersions: ["1"],
+      })
+      assert.deepEqual(response, {
+        type: "peer",
+        senderId: "server",
+        targetId: "browser",
+        selectedProtocolVersion: "1",
+      })
     })
-  })
-  
-  it("should correctly clear event handlers on reconnect", async () => {
-    // This reproduces an issue where the BrowserWebSocketClientAdapter.connect
-    // call registered event handlers on the websocket but didn't clear them
-    // up again on a second call to connect. This combined with the reconnect
-    // timer to produce the following sequence of events:
-    //
-    // * first call to connect creates a socket and registers an "open"
-    //   handler. The "open" handler will attempt to send a join message
-    // * The connection is slow, so the reconnect timer fires before "open",
-    //   the reconnect timer calls connect again. this.socket is now a new socket
-    // * The other end replies to the first socket, "open"
-    // * The original "open" handler attempts to send a message, but on the new
-    //   socket (because it uses this.socket), which isn't open yet, so we get an
-    //   error that the socket is not ready
-    const { socket, server } = await startServer(0)
-    let port = (server.address()!! as AddressInfo).port
-    const serverUrl = `ws://localhost:${port}`
-    const serverAdapter = new NodeWSServerAdapter(socket)
-    const browserAdapter = new BrowserWebSocketClientAdapter(serverUrl)
-
-    const peerId = "testclient" as PeerId
-    browserAdapter.connect(peerId)
-    // simulate the reconnect timer firing before the other end has responded
-    // (which works here because we haven't yielded to the event loop yet so
-    // the server, which is on the same event loop as us, can't respond)
-    browserAdapter.connect(peerId)
-    // Now await, so the server responds on the first socket, if the listeners
-    // are cleaned up correctly we shouldn't throw
-    await pause(1)
-  })
-})
 
-async function serverHelloGivenClientHello(
-  clientHello: Object
-): Promise<Object | null> {
-  const { socket, server } = await startServer(0)
-  let port = (server.address()!! as AddressInfo).port
-  const serverUrl = `ws://localhost:${port}`
-  const adapter = new NodeWSServerAdapter(socket)
-  const repo = new Repo({ network: [adapter], peerId: "server" as PeerId })
-
-  const clientSocket = new WebSocket(serverUrl)
-  await once(clientSocket, "open")
-  const serverHelloPromise = once(clientSocket, "message")
-
-  clientSocket.send(CBOR.encode(clientHello))
-
-  const serverHello = await serverHelloPromise
-  const message = CBOR.decode(serverHello[0] as Uint8Array)
-  return message
-}
-
-async function firstMessage(
-  socket: WebSocket.Server<any>
-): Promise<Object | null> {
-  return new Promise((resolve, reject) => {
-    socket.once("connection", ws => {
-      ws.once("message", (message: any) => {
-        resolve(message)
+    it("should return an error message if the protocol version is not supported", async () => {
+      const response = await serverResponse({
+        type: "join",
+        senderId: "browser",
+        supportedProtocolVersions: ["fake"],
       })
-      ws.once("error", (error: any) => {
-        reject(error)
+      assert.deepEqual(response, {
+        type: "error",
+        senderId: "server",
+        targetId: "browser",
+        message: "unsupported protocol version",
       })
     })
-    socket.once("error", error => {
-      reject(error)
+
+    it("should respond with protocol v1 if no protocol version is specified", async () => {
+      const response = await serverResponse({
+        type: "join",
+        senderId: "browser",
+      })
+      assert.deepEqual(response, {
+        type: "peer",
+        senderId: "server",
+        targetId: "browser",
+        selectedProtocolVersion: "1",
+      })
     })
   })
-}
+})
 
 export const pause = (t = 0) =>
   new Promise<void>(resolve => setTimeout(() => resolve(), t))

package/test/utilities/CreateWebSocketServer.ts

@@ -1,8 +0,0 @@
-import http from "http"
-import WebSocket from "ws"
-
-function createWebSocketServer(server: http.Server) {
-  return new WebSocket.Server({ server })
-}
-
-export { createWebSocketServer }

package/test/utilities/WebSockets.ts

@@ -1,34 +0,0 @@
-import http from "http"
-import { createWebSocketServer } from "./CreateWebSocketServer.js"
-import WebSocket from "ws"
-
-function startServer(port: number) {
-  const server = http.createServer()
-  const socket = createWebSocketServer(server)
-  return new Promise<{
-    socket: WebSocket.Server
-    server: http.Server
-  }>(resolve => {
-    server.listen(port, () => resolve({ socket, server }))
-  })
-}
-
-type WebSocketState =
-  | typeof WebSocket.CONNECTING
-  | typeof WebSocket.OPEN
-  | typeof WebSocket.CLOSING
-  | typeof WebSocket.CLOSED
-
-function waitForSocketState(socket: WebSocket, state: WebSocketState) {
-  return new Promise<void>(function (resolve) {
-    setTimeout(function () {
-      if (socket.readyState === state) {
-        resolve()
-      } else {
-        waitForSocketState(socket, state).then(resolve)
-      }
-    }, 5)
-  })
-}
-
-export { startServer, waitForSocketState }