@automerge/automerge-repo-network-websocket 1.1.0-alpha.7 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automerge/automerge-repo-network-websocket",
-  "version": "1.1.0-alpha.7",
+  "version": "1.1.0",
   "description": "isomorphic node/browser Websocket network adapter for Automerge Repo",
   "repository": "https://github.com/automerge/automerge-repo/tree/master/packages/automerge-repo-network-websocket",
   "author": "Peter van Hardenberg <pvh@pvh.ca>",
@@ -13,8 +13,9 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@automerge/automerge-repo": "^1.1.0-alpha.7",
+    "@automerge/automerge-repo": "1.1.0",
     "cbor-x": "^1.3.0",
+    "debug": "^4.3.4",
     "eventemitter3": "^5.0.1",
     "isomorphic-ws": "^5.0.0",
     "ws": "^8.7.0"
@@ -30,5 +31,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9a4711e39c93273d992c5686257246ddfaaafddd"
+  "gitHead": "e9e7d3f27ec2ac8a2e9d122ece80598918940067"
 }

package/src/BrowserWebSocketClientAdapter.ts

@@ -1,7 +1,7 @@
 import {
   NetworkAdapter,
-  type PeerId,
-  type PeerMetadata,
+  PeerId,
+  PeerMetadata,
   cbor,
 } from "@automerge/automerge-repo"
 import WebSocket from "isomorphic-ws"
@@ -12,173 +12,163 @@ import {
   FromClientMessage,
   FromServerMessage,
   JoinMessage,
-  PeerMessage,
+  isErrorMessage,
+  isPeerMessage,
 } from "./messages.js"
 import { ProtocolV1 } from "./protocolVersion.js"
-
-const log = debug("WebsocketClient")
+import { assert } from "./assert.js"
+import { toArrayBuffer } from "./toArrayBuffer.js"
 
 abstract class WebSocketNetworkAdapter extends NetworkAdapter {
   socket?: WebSocket
 }
 
 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
+  #isReady: boolean = false
+  #retryIntervalId?: TimeoutId
+  #log = debug("automerge-repo:websocket:browser")
 
-  url: string
+  remotePeerId?: PeerId // this adapter only connects to one remote client at a time
 
-  constructor(url: string) {
+  constructor(
+    public readonly url: string,
+    public readonly retryInterval = 5000
+  ) {
     super()
-    this.url = url
+    this.#log = this.#log.extend(url)
   }
 
-  connect(peerId: PeerId, peerMetadata: PeerMetadata) {
-    // If we're reconnecting  make sure we remove the old event listeners
-    // before creating a new connection.
-    if (this.socket) {
+  connect(peerId: PeerId, peerMetadata?: PeerMetadata) {
+    if (!this.socket || !this.peerId) {
+      // first time connecting
+      this.#log("connecting")
+      this.peerId = peerId
+      this.peerMetadata = peerMetadata ?? {}
+    } else {
+      this.#log("reconnecting")
+      assert(peerId === this.peerId)
+      // Remove the old event listeners before creating a new connection.
       this.socket.removeEventListener("open", this.onOpen)
       this.socket.removeEventListener("close", this.onClose)
       this.socket.removeEventListener("message", this.onMessage)
+      this.socket.removeEventListener("error", this.onError)
     }
+    // Wire up retries
+    if (!this.#retryIntervalId)
+      this.#retryIntervalId = setInterval(() => {
+        this.connect(peerId, peerMetadata)
+      }, this.retryInterval)
 
-    if (!this.timerId) {
-      this.timerId = setInterval(() => this.connect(peerId, peerMetadata), 5000)
-    }
-
-    this.peerId = peerId
-    this.peerMetadata = peerMetadata
     this.socket = new WebSocket(this.url)
+
     this.socket.binaryType = "arraybuffer"
 
     this.socket.addEventListener("open", this.onOpen)
     this.socket.addEventListener("close", this.onClose)
     this.socket.addEventListener("message", this.onMessage)
+    this.socket.addEventListener("error", this.onError)
 
-    // mark this adapter as ready if we haven't received an ack in 1 second.
+    // Mark this adapter as ready if we haven't received an ack in 1 second.
     // We might hear back from the other end at some point but we shouldn't
     // hold up marking things as unavailable for any longer
-    setTimeout(() => {
-      if (!this.#startupComplete) {
-        this.#startupComplete = true
-        this.emit("ready", { network: this })
-      }
-    }, 1000)
-
+    setTimeout(() => this.#ready(), 1000)
     this.join()
   }
 
   onOpen = () => {
-    log(`@ ${this.url}: open`)
-    clearInterval(this.timerId)
-    this.timerId = undefined
-    this.send(joinMessage(this.peerId!, this.peerMetadata!))
+    this.#log("open")
+    clearInterval(this.#retryIntervalId)
+    this.#retryIntervalId = undefined
+    this.join()
   }
 
   // When a socket closes, or disconnects, remove it from the array.
   onClose = () => {
-    log(`${this.url}: close`)
-
-    if (this.remotePeerId) {
+    this.#log("close")
+    if (this.remotePeerId)
       this.emit("peer-disconnected", { peerId: this.remotePeerId })
-    }
 
-    if (!this.timerId) {
-      if (this.peerId) {
-        this.connect(this.peerId, this.peerMetadata!)
-      }
-    }
+    if (this.retryInterval > 0 && !this.#retryIntervalId)
+      // try to reconnect
+      setTimeout(() => {
+        assert(this.peerId)
+        return this.connect(this.peerId, this.peerMetadata)
+      }, this.retryInterval)
   }
 
   onMessage = (event: WebSocket.MessageEvent) => {
     this.receiveMessage(event.data as Uint8Array)
   }
 
-  join() {
-    if (!this.socket) {
-      throw new Error("WTF, get a socket")
+  onError = (event: WebSocket.ErrorEvent) => {
+    const { code } = event.error
+    if (code === "ECONNREFUSED") {
+      this.#log("Connection refused, retrying...")
+    } else {
+      /* c8 ignore next */
+      throw event.error
     }
+  }
+
+  #ready() {
+    if (this.#isReady) return
+    this.#isReady = true
+    this.emit("ready", { network: this })
+  }
+
+  join() {
+    assert(this.peerId)
+    assert(this.socket)
     if (this.socket.readyState === WebSocket.OPEN) {
       this.send(joinMessage(this.peerId!, this.peerMetadata!))
     } else {
-      // The onOpen handler automatically sends a join message
+      // We'll try again in the `onOpen` handler
     }
   }
 
   disconnect() {
-    if (!this.socket) {
-      throw new Error("WTF, get a socket")
-    }
-    this.send({ type: "leave", senderId: this.peerId! })
+    assert(this.peerId)
+    assert(this.socket)
+    this.send({ type: "leave", senderId: this.peerId })
   }
 
   send(message: FromClientMessage) {
-    if ("data" in message && message.data.byteLength === 0) {
-      throw new Error("tried to send a zero-length message")
-    }
-
-    if (!this.peerId) {
-      throw new Error("Why don't we have a PeerID?")
-    }
-
-    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
-      throw new Error("Websocket Socket not ready!")
-    }
+    if ("data" in message && message.data?.byteLength === 0)
+      throw new Error("Tried to send a zero-length message")
+    assert(this.peerId)
+    assert(this.socket)
+    if (this.socket.readyState !== WebSocket.OPEN)
+      throw new Error(`Websocket not ready (${this.socket.readyState})`)
 
     const encoded = cbor.encode(message)
-    // This incantation deals with websocket sending the whole
-    // underlying buffer even if we just have a uint8array view on it
-    const arrayBuf = encoded.buffer.slice(
-      encoded.byteOffset,
-      encoded.byteOffset + encoded.byteLength
-    )
-
-    this.socket?.send(arrayBuf)
+    this.socket.send(toArrayBuffer(encoded))
   }
 
-  announceConnection(peerId: PeerId, peerMetadata: PeerMetadata) {
-    // return a peer object
-    const myPeerId = this.peerId
-    if (!myPeerId) {
-      throw new Error("we should have a peer ID by now")
-    }
-    if (!this.#startupComplete) {
-      this.#startupComplete = true
-      this.emit("ready", { network: this })
-    }
-    this.remotePeerId = peerId
-    this.emit("peer-candidate", { peerId, peerMetadata })
+  peerCandidate(remotePeerId: PeerId, peerMetadata: PeerMetadata) {
+    assert(this.socket)
+    this.#ready()
+    this.remotePeerId = remotePeerId
+    this.emit("peer-candidate", {
+      peerId: remotePeerId,
+      peerMetadata,
+    })
   }
 
-  receiveMessage(message: Uint8Array) {
-    const decoded: FromServerMessage = cbor.decode(new Uint8Array(message))
-
-    const { type, senderId } = decoded
-
-    const socket = this.socket
-    if (!socket) {
-      throw new Error("Missing socket at receiveMessage")
-    }
+  receiveMessage(messageBytes: Uint8Array) {
+    const message: FromServerMessage = cbor.decode(new Uint8Array(messageBytes))
 
-    if (message.byteLength === 0) {
+    assert(this.socket)
+    if (messageBytes.byteLength === 0)
       throw new Error("received a zero-length message")
-    }
 
-    switch (type) {
-      case "peer": {
-        const { peerMetadata } = decoded
-        log(`peer: ${senderId}`)
-        this.announceConnection(senderId, peerMetadata)
-        break
-      }
-      case "error":
-        log(`error: ${decoded.message}`)
-        break
-      default:
-        this.emit("message", decoded)
+    if (isPeerMessage(message)) {
+      const { peerMetadata } = message
+      this.#log(`peer: ${message.senderId}`)
+      this.peerCandidate(message.senderId, peerMetadata)
+    } else if (isErrorMessage(message)) {
+      this.#log(`error: ${message.message}`)
+    } else {
+      this.emit("message", message)
     }
   }
 }
@@ -194,3 +184,5 @@ function joinMessage(
     supportedProtocolVersions: [ProtocolV1],
   }
 }
+
+type TimeoutId = ReturnType<typeof setTimeout> //  https://stackoverflow.com/questions/45802988

package/src/NodeWSServerAdapter.ts

@@ -10,41 +10,41 @@ import {
   type PeerMetadata,
   type PeerId,
 } from "@automerge/automerge-repo"
-import { FromClientMessage, FromServerMessage } from "./messages.js"
+import {
+  FromClientMessage,
+  FromServerMessage,
+  isJoinMessage,
+  isLeaveMessage,
+} from "./messages.js"
 import { ProtocolV1, ProtocolVersion } from "./protocolVersion.js"
+import assert from "assert"
+import { toArrayBuffer } from "./toArrayBuffer.js"
 
 const { encode, decode } = cborHelpers
 
-interface WebSocketWithIsAlive extends WebSocket {
-  isAlive: boolean
-}
-
 export class NodeWSServerAdapter extends NetworkAdapter {
-  server: WebSocketServer
   sockets: { [peerId: PeerId]: WebSocket } = {}
 
-  constructor(server: WebSocketServer) {
+  constructor(
+    private server: WebSocketServer,
+    private keepAliveInterval = 5000
+  ) {
     super()
-    this.server = server
   }
 
   connect(peerId: PeerId, peerMetadata: PeerMetadata) {
     this.peerId = peerId
     this.peerMetadata = peerMetadata
 
-    this.server.on("close", function close() {
-      clearInterval(interval)
+    this.server.on("close", () => {
+      clearInterval(keepAliveId)
+      this.disconnect()
     })
 
     this.server.on("connection", (socket: WebSocketWithIsAlive) => {
       // When a socket closes, or disconnects, remove it from our list
       socket.on("close", () => {
-        for (const [otherPeerId, otherSocket] of Object.entries(this.sockets)) {
-          if (socket === otherSocket) {
-            this.emit("peer-disconnected", { peerId: otherPeerId as PeerId })
-            delete this.sockets[otherPeerId as PeerId]
-          }
-        }
+        this.#removeSocket(socket)
       })
 
       socket.on("message", message =>
@@ -58,136 +58,132 @@ export class NodeWSServerAdapter extends NetworkAdapter {
       this.emit("ready", { network: this })
     })
 
-    // Every interval, terminate connections to lost clients,
-    // then mark all clients as potentially dead and then ping them.
-    const interval = setInterval(() => {
-      ;(this.server.clients as Set<WebSocketWithIsAlive>).forEach(socket => {
-        if (socket.isAlive === false) {
-          // Make sure we clean up this socket even though we're terminating.
-          // This might be unnecessary but I have read reports of the close() not happening for 30s.
-          for (const [otherPeerId, otherSocket] of Object.entries(
-            this.sockets
-          )) {
-            if (socket === otherSocket) {
-              this.emit("peer-disconnected", { peerId: otherPeerId as PeerId })
-              delete this.sockets[otherPeerId as PeerId]
-            }
-          }
-          return socket.terminate()
+    const keepAliveId = setInterval(() => {
+      // Terminate connections to lost clients
+      const clients = this.server.clients as Set<WebSocketWithIsAlive>
+      clients.forEach(socket => {
+        if (socket.isAlive) {
+          // Mark all clients as potentially dead until we hear from them
+          socket.isAlive = false
+          socket.ping()
+        } else {
+          this.#terminate(socket)
         }
-        socket.isAlive = false
-        socket.ping()
       })
-    }, 5000)
+    }, this.keepAliveInterval)
   }
 
   disconnect() {
-    // throw new Error("The server doesn't join channels.")
+    const clients = this.server.clients as Set<WebSocketWithIsAlive>
+    clients.forEach(socket => {
+      this.#terminate(socket)
+      this.#removeSocket(socket)
+    })
   }
 
   send(message: FromServerMessage) {
-    if ("data" in message && message.data.byteLength === 0) {
-      throw new Error("tried to send a zero-length message")
-    }
+    assert("targetId" in message && message.targetId !== undefined)
+    if ("data" in message && message.data?.byteLength === 0)
+      throw new Error("Tried to send a zero-length message")
+
     const senderId = this.peerId
-    if (!senderId) {
-      throw new Error("No peerId set for the websocket server network adapter.")
-    }
+    assert(senderId, "No peerId set for the websocket server network adapter.")
+
+    const socket = this.sockets[message.targetId]
 
-    if (this.sockets[message.targetId] === undefined) {
-      log(`Tried to send message to disconnected peer: ${message.targetId}`)
+    if (!socket) {
+      log(`Tried to send to disconnected peer: ${message.targetId}`)
       return
     }
 
     const encoded = encode(message)
-    // This incantation deals with websocket sending the whole
-    // underlying buffer even if we just have a uint8array view on it
-    const arrayBuf = encoded.buffer.slice(
-      encoded.byteOffset,
-      encoded.byteOffset + encoded.byteLength
-    )
-
-    this.sockets[message.targetId]?.send(arrayBuf)
+    const arrayBuf = toArrayBuffer(encoded)
+
+    socket.send(arrayBuf)
   }
 
-  receiveMessage(message: Uint8Array, socket: WebSocket) {
-    const cbor: FromClientMessage = decode(message)
+  receiveMessage(messageBytes: Uint8Array, socket: WebSocket) {
+    const message: FromClientMessage = decode(messageBytes)
 
-    const { type, senderId } = cbor
+    const { type, senderId } = message
 
     const myPeerId = this.peerId
-    if (!myPeerId) {
-      throw new Error("Missing my peer ID.")
-    }
-    log(
-      `[${senderId}->${myPeerId}${
-        "documentId" in cbor ? "@" + cbor.documentId : ""
-      }] ${type} | ${message.byteLength} bytes`
-    )
-    switch (type) {
-      case "join":
-        {
-          const existingSocket = this.sockets[senderId]
-          if (existingSocket) {
-            if (existingSocket.readyState === WebSocket.OPEN) {
-              existingSocket.close()
-            }
-            this.emit("peer-disconnected", { peerId: senderId })
-          }
-
-          const { peerMetadata } = cbor
-          // Let the rest of the system know that we have a new connection.
-          this.emit("peer-candidate", {
-            peerId: senderId,
-            peerMetadata,
-          })
-          this.sockets[senderId] = socket
-
-          // In this client-server connection, there's only ever one peer: us!
-          // (and we pretend to be joined to every channel)
-          const selectedProtocolVersion = selectProtocol(
-            cbor.supportedProtocolVersions
-          )
-          if (selectedProtocolVersion === null) {
-            this.send({
-              type: "error",
-              senderId: this.peerId!,
-              message: "unsupported protocol version",
-              targetId: senderId,
-            })
-            this.sockets[senderId].close()
-            delete this.sockets[senderId]
-          } else {
-            this.send({
-              type: "peer",
-              senderId: this.peerId!,
-              peerMetadata: this.peerMetadata!,
-              selectedProtocolVersion: ProtocolV1,
-              targetId: senderId,
-            })
-          }
+    assert(myPeerId)
+
+    const documentId = "documentId" in message ? "@" + message.documentId : ""
+    const { byteLength } = messageBytes
+    log(`[${senderId}->${myPeerId}${documentId}] ${type} | ${byteLength} bytes`)
+
+    if (isJoinMessage(message)) {
+      const { peerMetadata, supportedProtocolVersions } = message
+      const existingSocket = this.sockets[senderId]
+      if (existingSocket) {
+        if (existingSocket.readyState === WebSocket.OPEN) {
+          existingSocket.close()
         }
-        break
-      case "leave":
-        // It doesn't seem like this gets called;
-        // we handle leaving in the socket close logic
-        // TODO: confirm this
-        // ?
-        break
-
-      default:
-        this.emit("message", cbor)
-        break
+        this.emit("peer-disconnected", { peerId: senderId })
+      }
+
+      // Let the repo know that we have a new connection.
+      this.emit("peer-candidate", { peerId: senderId, peerMetadata })
+      this.sockets[senderId] = socket
+
+      const selectedProtocolVersion = selectProtocol(supportedProtocolVersions)
+      if (selectedProtocolVersion === null) {
+        this.send({
+          type: "error",
+          senderId: this.peerId!,
+          message: "unsupported protocol version",
+          targetId: senderId,
+        })
+        this.sockets[senderId].close()
+        delete this.sockets[senderId]
+      } else {
+        this.send({
+          type: "peer",
+          senderId: this.peerId!,
+          peerMetadata: this.peerMetadata!,
+          selectedProtocolVersion: ProtocolV1,
+          targetId: senderId,
+        })
+      }
+    } else if (isLeaveMessage(message)) {
+      const { senderId } = message
+      const socket = this.sockets[senderId]
+      /* c8 ignore next */
+      if (!socket) return
+      this.#terminate(socket as WebSocketWithIsAlive)
+    } else {
+      this.emit("message", message)
     }
   }
-}
 
-function selectProtocol(versions?: ProtocolVersion[]): ProtocolVersion | null {
-  if (versions === undefined) {
-    return ProtocolV1
+  #terminate(socket: WebSocketWithIsAlive) {
+    this.#removeSocket(socket)
+    socket.terminate()
+  }
+
+  #removeSocket(socket: WebSocketWithIsAlive) {
+    const peerId = this.#peerIdBySocket(socket)
+    if (!peerId) return
+    this.emit("peer-disconnected", { peerId })
+    delete this.sockets[peerId as PeerId]
   }
-  if (versions.includes(ProtocolV1)) {
-    return ProtocolV1
+
+  #peerIdBySocket = (socket: WebSocket) => {
+    const isThisSocket = (peerId: string) =>
+      this.sockets[peerId as PeerId] === socket
+    const result = Object.keys(this.sockets).find(isThisSocket) as PeerId
+    return result ?? null
   }
+}
+
+const selectProtocol = (versions?: ProtocolVersion[]) => {
+  if (versions === undefined) return ProtocolV1
+  if (versions.includes(ProtocolV1)) return ProtocolV1
   return null
 }
+
+interface WebSocketWithIsAlive extends WebSocket {
+  isAlive: boolean
+}

package/src/assert.ts

@@ -0,0 +1,28 @@
+/* c8 ignore start */
+
+export function assert(value: boolean, message?: string): asserts value
+export function assert<T>(
+  value: T | undefined,
+  message?: string
+): asserts value is T
+export function assert(value: any, message = "Assertion failed") {
+  if (value === false || value === null || value === undefined) {
+    const error = new Error(trimLines(message))
+    error.stack = removeLine(error.stack, "assert.ts")
+    throw error
+  }
+}
+
+const trimLines = (s: string) =>
+  s
+    .split("\n")
+    .map(s => s.trim())
+    .join("\n")
+
+const removeLine = (s = "", targetText: string) =>
+  s
+    .split("\n")
+    .filter(line => !line.includes(targetText))
+    .join("\n")
+
+/* c8 ignore end */

package/src/messages.ts

@@ -46,11 +46,26 @@ export type ErrorMessage = {
   targetId: PeerId
 }
 
-// This adapter doesn't use the network adapter Message types, it has its own idea of how to handle
-// join/leave
-
 /** A message from the client to the server */
 export type FromClientMessage = JoinMessage | LeaveMessage | Message
 
 /** A message from the server to the client */
 export type FromServerMessage = PeerMessage | ErrorMessage | Message
+
+// TYPE GUARDS
+
+export const isJoinMessage = (
+  message: FromClientMessage
+): message is JoinMessage => message.type === "join"
+
+export const isLeaveMessage = (
+  message: FromClientMessage
+): message is LeaveMessage => message.type === "leave"
+
+export const isPeerMessage = (
+  message: FromServerMessage
+): message is PeerMessage => message.type === "peer"
+
+export const isErrorMessage = (
+  message: FromServerMessage
+): message is ErrorMessage => message.type === "error"

package/src/toArrayBuffer.ts

@@ -0,0 +1,8 @@
+/**
+ * This incantation deals with websocket sending the whole underlying buffer even if we just have a
+ * uint8array view on it
+ */
+export const toArrayBuffer = (bytes: Uint8Array) => {
+  const { buffer, byteOffset, byteLength } = bytes
+  return buffer.slice(byteOffset, byteOffset + byteLength)
+}