@automerge/automerge-repo-network-websocket 0.0.1

package/.mocharc.json

@@ -0,0 +1,5 @@
+{
+  "extension": ["ts"],
+  "spec": "test/*.test.ts",
+  "loader": "ts-node/esm"
+}

package/README.md

@@ -0,0 +1,5 @@
+# Automerge-Repo Network: Websocket
+
+Includes two implementations, a Websocket client and a Websocket server. These are used by the example sync-server.
+
+The package uses isomorphic-ws to share code between node and the browser, but the server code is node only due to lack of browser support.

package/dist/BrowserWebSocketClientAdapter.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="ws" />
+import { ChannelId, NetworkAdapter, PeerId } from "@automerge/automerge-repo";
+import WebSocket from "isomorphic-ws";
+declare abstract class WebSocketNetworkAdapter extends NetworkAdapter {
+    socket?: WebSocket;
+}
+export declare class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
+    timerId?: NodeJS.Timer;
+    url: string;
+    channels: ChannelId[];
+    constructor(url: string);
+    connect(peerId: PeerId): void;
+    join(channelId: ChannelId): void;
+    leave(channelId: ChannelId): void;
+    sendMessage(targetId: PeerId, channelId: ChannelId, message: Uint8Array, broadcast: boolean): void;
+    announceConnection(channelId: ChannelId, peerId: PeerId): void;
+    receiveMessage(message: Uint8Array): void;
+}
+export {};
+//# sourceMappingURL=BrowserWebSocketClientAdapter.d.ts.map

package/dist/BrowserWebSocketClientAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserWebSocketClientAdapter.d.ts","sourceRoot":"","sources":["../src/BrowserWebSocketClientAdapter.ts"],"names":[],"mappings":";;AAAA,OAAO,EACL,SAAS,EAET,cAAc,EACd,MAAM,EACP,MAAM,2BAA2B,CAAA;AAElC,OAAO,SAAS,MAAM,eAAe,CAAA;AAKrC,uBAAe,uBAAwB,SAAQ,cAAc;IAC3D,MAAM,CAAC,EAAE,SAAS,CAAA;CACnB;AAED,qBAAa,6BAA8B,SAAQ,uBAAuB;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC,KAAK,CAAA;IACtB,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,SAAS,EAAE,CAAK;gBAEd,GAAG,EAAE,MAAM;IAKvB,OAAO,CAAC,MAAM,EAAE,MAAM;IA8BtB,IAAI,CAAC,SAAS,EAAE,SAAS;IA6BzB,KAAK,CAAC,SAAS,EAAE,SAAS;IAU1B,WAAW,CACT,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,OAAO;IAgCpB,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM;IAUvD,cAAc,CAAC,OAAO,EAAE,UAAU;CAoCnC"}

package/dist/BrowserWebSocketClientAdapter.js

@@ -0,0 +1,124 @@
+import { NetworkAdapter, } from "@automerge/automerge-repo";
+import * as CBOR from "cbor-x";
+import WebSocket from "isomorphic-ws";
+import debug from "debug";
+const log = debug("WebsocketClient");
+class WebSocketNetworkAdapter extends NetworkAdapter {
+    socket;
+}
+export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
+    timerId;
+    url;
+    channels = [];
+    constructor(url) {
+        super();
+        this.url = url;
+    }
+    connect(peerId) {
+        if (!this.timerId) {
+            this.timerId = setInterval(() => this.connect(peerId), 5000);
+        }
+        this.peerId = peerId;
+        this.socket = new WebSocket(this.url);
+        this.socket.binaryType = "arraybuffer";
+        this.socket.addEventListener("open", () => {
+            log(`@ ${this.url}: open`);
+            clearInterval(this.timerId);
+            this.timerId = undefined;
+            this.channels.forEach(c => this.join(c));
+        });
+        // When a socket closes, or disconnects, remove it from the array.
+        this.socket.addEventListener("close", () => {
+            log(`${this.url}: close`);
+            if (!this.timerId) {
+                this.connect(peerId);
+            }
+            // log("Disconnected from server")
+        });
+        this.socket.addEventListener("message", (event) => this.receiveMessage(event.data));
+    }
+    join(channelId) {
+        // TODO: the network subsystem should manage this
+        if (!this.channels.includes(channelId)) {
+            this.channels.push(channelId);
+        }
+        if (!this.socket) {
+            throw new Error("WTF, get a socket");
+        }
+        if (this.socket.readyState === WebSocket.OPEN) {
+            this.socket.send(CBOR.encode({ type: "join", channelId, senderId: this.peerId }));
+        }
+        else {
+            this.socket.addEventListener("open", () => {
+                if (!this.socket) {
+                    throw new Error("WTF, get a socket");
+                }
+                this.socket.send(CBOR.encode({ type: "join", channelId, senderId: this.peerId }));
+            }, { once: true });
+        }
+    }
+    leave(channelId) {
+        this.channels = this.channels.filter(c => c !== channelId);
+        if (!this.socket) {
+            throw new Error("WTF, get a socket");
+        }
+        this.socket.send(CBOR.encode({ type: "leave", channelId, senderId: this.peerId }));
+    }
+    sendMessage(targetId, channelId, message, broadcast) {
+        if (message.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?");
+        }
+        const decoded = {
+            senderId: this.peerId,
+            targetId,
+            channelId,
+            type: "message",
+            message,
+            broadcast,
+        };
+        const encoded = CBOR.encode(decoded);
+        // 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);
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error("Websocket Socket not ready!");
+        }
+        this.socket.send(arrayBuf);
+    }
+    announceConnection(channelId, peerId) {
+        // return a peer object
+        const myPeerId = this.peerId;
+        if (!myPeerId) {
+            throw new Error("we should have a peer ID by now");
+        }
+        this.emit("peer-candidate", { peerId, channelId });
+    }
+    receiveMessage(message) {
+        const decoded = CBOR.decode(new Uint8Array(message));
+        const { type, senderId, targetId, channelId, message: messageData, broadcast, } = decoded;
+        const socket = this.socket;
+        if (!socket) {
+            throw new Error("Missing socket at receiveMessage");
+        }
+        if (message.byteLength === 0) {
+            throw new Error("received a zero-length message");
+        }
+        switch (type) {
+            case "peer":
+                log(`peer: ${senderId}, ${channelId}`);
+                this.announceConnection(channelId, senderId);
+                break;
+            default:
+                this.emit("message", {
+                    channelId,
+                    senderId,
+                    targetId,
+                    message: new Uint8Array(messageData),
+                    broadcast,
+                });
+        }
+    }
+}

package/dist/NodeWSServerAdapter.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="ws" />
+import { WebSocket, type WebSocketServer } from "isomorphic-ws";
+import { ChannelId, NetworkAdapter, PeerId } from "@automerge/automerge-repo";
+export declare class NodeWSServerAdapter extends NetworkAdapter {
+    server: WebSocketServer;
+    sockets: {
+        [peerId: PeerId]: WebSocket;
+    };
+    constructor(server: WebSocketServer);
+    connect(peerId: PeerId): void;
+    join(docId: ChannelId): void;
+    leave(docId: ChannelId): void;
+    sendMessage(targetId: PeerId, channelId: ChannelId, message: Uint8Array, broadcast: boolean): void;
+    receiveMessage(message: Uint8Array, socket: WebSocket): void;
+}
+//# sourceMappingURL=NodeWSServerAdapter.d.ts.map

package/dist/NodeWSServerAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeWSServerAdapter.d.ts","sourceRoot":"","sources":["../src/NodeWSServerAdapter.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAK/D,OAAO,EACL,SAAS,EAET,cAAc,EACd,MAAM,EACP,MAAM,2BAA2B,CAAA;AAElC,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,MAAM,EAAE,eAAe,CAAA;IACvB,OAAO,EAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAK;gBAEjC,MAAM,EAAE,eAAe;IAKnC,OAAO,CAAC,MAAM,EAAE,MAAM;IAmBtB,IAAI,CAAC,KAAK,EAAE,SAAS;IAIrB,KAAK,CAAC,KAAK,EAAE,SAAS;IAItB,WAAW,CACT,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,OAAO;IAsCpB,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS;CAmDtD"}

package/dist/NodeWSServerAdapter.js

@@ -0,0 +1,97 @@
+import * as CBOR from "cbor-x";
+import debug from "debug";
+const log = debug("WebsocketServer");
+import { NetworkAdapter, } from "@automerge/automerge-repo";
+export class NodeWSServerAdapter extends NetworkAdapter {
+    server;
+    sockets = {};
+    constructor(server) {
+        super();
+        this.server = server;
+    }
+    connect(peerId) {
+        this.peerId = peerId;
+        this.server.on("connection", socket => {
+            // 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 });
+                        delete this.sockets[otherPeerId];
+                    }
+                }
+            });
+            socket.on("message", message => this.receiveMessage(message, socket));
+        });
+    }
+    join(docId) {
+        // throw new Error("The server doesn't join channels.")
+    }
+    leave(docId) {
+        // throw new Error("The server doesn't join channels.")
+    }
+    sendMessage(targetId, channelId, message, broadcast) {
+        if (message.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.");
+        }
+        if (this.sockets[targetId] === undefined) {
+            log(`Tried to send message to disconnected peer: ${targetId}`);
+            return;
+        }
+        const decoded = {
+            senderId,
+            targetId,
+            channelId,
+            type: "sync",
+            message,
+            broadcast,
+        };
+        const encoded = CBOR.encode(decoded);
+        // 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);
+        log(`[${senderId}->${targetId}@${channelId}] "sync" | ${arrayBuf.byteLength} bytes`);
+        this.sockets[targetId].send(arrayBuf);
+    }
+    receiveMessage(message, socket) {
+        const cbor = CBOR.decode(message);
+        const { type, channelId, senderId, targetId, message: data, broadcast, } = cbor;
+        const myPeerId = this.peerId;
+        if (!myPeerId) {
+            throw new Error("Missing my peer ID.");
+        }
+        log(`[${senderId}->${myPeerId}@${channelId}] ${type} | ${message.byteLength} bytes`);
+        switch (type) {
+            case "join":
+                // Let the rest of the system know that we have a new connection.
+                this.emit("peer-candidate", { peerId: senderId, channelId });
+                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)
+                socket.send(CBOR.encode({ type: "peer", senderId: this.peerId, channelId }));
+                break;
+            case "leave":
+                // It doesn't seem like this gets called;
+                // we handle leaving in the socket close logic
+                // TODO: confirm this
+                // ?
+                break;
+            case "message":
+                this.emit("message", {
+                    senderId,
+                    targetId,
+                    channelId,
+                    message: new Uint8Array(data),
+                    broadcast,
+                });
+                break;
+            default:
+                // log("unrecognized message type")
+                break;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { BrowserWebSocketClientAdapter } from "./BrowserWebSocketClientAdapter.js";
+export { NodeWSServerAdapter } from "./NodeWSServerAdapter.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAA;AAClF,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { BrowserWebSocketClientAdapter } from "./BrowserWebSocketClientAdapter.js";
+export { NodeWSServerAdapter } from "./NodeWSServerAdapter.js";

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@automerge/automerge-repo-network-websocket",
+  "version": "0.0.1",
+  "description": "isomorphic node/browser Websocket network adapter for Automerge Repo",
+  "repository": "https://github.com/pvh/automerge-repo",
+  "author": "Peter van Hardenberg <pvh@pvh.ca>",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "watch": "npm-watch",
+    "test": "mocha --no-warnings --experimental-specifier-resolution=node --exit"
+  },
+  "dependencies": {
+    "@automerge/automerge-repo": "^0.0.1",
+    "cbor-x": "^1.3.0",
+    "eventemitter3": "^4.0.7",
+    "isomorphic-ws": "^5.0.0"
+  },
+  "watch": {
+    "build": {
+      "patterns": "./src/**/*",
+      "extensions": [
+        ".ts"
+      ]
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "e572f26ae416140b025c3ba557d9f781abbdada1"
+}

package/src/BrowserWebSocketClientAdapter.ts

@@ -0,0 +1,178 @@
+import {
+  ChannelId,
+  InboundMessagePayload,
+  NetworkAdapter,
+  PeerId,
+} from "@automerge/automerge-repo"
+import * as CBOR from "cbor-x"
+import WebSocket from "isomorphic-ws"
+
+import debug from "debug"
+const log = debug("WebsocketClient")
+
+abstract class WebSocketNetworkAdapter extends NetworkAdapter {
+  socket?: WebSocket
+}
+
+export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
+  timerId?: NodeJS.Timer
+  url: string
+  channels: ChannelId[] = []
+
+  constructor(url: string) {
+    super()
+    this.url = url
+  }
+
+  connect(peerId: PeerId) {
+    if (!this.timerId) {
+      this.timerId = setInterval(() => this.connect(peerId), 5000)
+    }
+
+    this.peerId = peerId
+    this.socket = new WebSocket(this.url)
+    this.socket.binaryType = "arraybuffer"
+
+    this.socket.addEventListener("open", () => {
+      log(`@ ${this.url}: open`)
+      clearInterval(this.timerId)
+      this.timerId = undefined
+      this.channels.forEach(c => this.join(c))
+    })
+
+    // When a socket closes, or disconnects, remove it from the array.
+    this.socket.addEventListener("close", () => {
+      log(`${this.url}: close`)
+      if (!this.timerId) {
+        this.connect(peerId)
+      }
+      // log("Disconnected from server")
+    })
+
+    this.socket.addEventListener("message", (event: WebSocket.MessageEvent) =>
+      this.receiveMessage(event.data as Uint8Array)
+    )
+  }
+
+  join(channelId: ChannelId) {
+    // TODO: the network subsystem should manage this
+    if (!this.channels.includes(channelId)) {
+      this.channels.push(channelId)
+    }
+
+    if (!this.socket) {
+      throw new Error("WTF, get a socket")
+    }
+    if (this.socket.readyState === WebSocket.OPEN) {
+      this.socket.send(
+        CBOR.encode({ type: "join", channelId, senderId: this.peerId })
+      )
+    } else {
+      this.socket.addEventListener(
+        "open",
+        () => {
+          if (!this.socket) {
+            throw new Error("WTF, get a socket")
+          }
+          this.socket.send(
+            CBOR.encode({ type: "join", channelId, senderId: this.peerId })
+          )
+        },
+        { once: true }
+      )
+    }
+  }
+
+  leave(channelId: ChannelId) {
+    this.channels = this.channels.filter(c => c !== channelId)
+    if (!this.socket) {
+      throw new Error("WTF, get a socket")
+    }
+    this.socket.send(
+      CBOR.encode({ type: "leave", channelId, senderId: this.peerId })
+    )
+  }
+
+  sendMessage(
+    targetId: PeerId,
+    channelId: ChannelId,
+    message: Uint8Array,
+    broadcast: boolean
+  ) {
+    if (message.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?")
+    }
+
+    const decoded: InboundMessagePayload = {
+      senderId: this.peerId,
+      targetId,
+      channelId,
+      type: "message",
+      message,
+      broadcast,
+    }
+
+    const encoded = CBOR.encode(decoded)
+
+    // 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
+    )
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      throw new Error("Websocket Socket not ready!")
+    }
+    this.socket.send(arrayBuf)
+  }
+
+  announceConnection(channelId: ChannelId, peerId: PeerId) {
+    // return a peer object
+    const myPeerId = this.peerId
+    if (!myPeerId) {
+      throw new Error("we should have a peer ID by now")
+    }
+
+    this.emit("peer-candidate", { peerId, channelId })
+  }
+
+  receiveMessage(message: Uint8Array) {
+    const decoded: InboundMessagePayload = CBOR.decode(new Uint8Array(message))
+
+    const {
+      type,
+      senderId,
+      targetId,
+      channelId,
+      message: messageData,
+      broadcast,
+    } = decoded
+
+    const socket = this.socket
+    if (!socket) {
+      throw new Error("Missing socket at receiveMessage")
+    }
+
+    if (message.byteLength === 0) {
+      throw new Error("received a zero-length message")
+    }
+
+    switch (type) {
+      case "peer":
+        log(`peer: ${senderId}, ${channelId}`)
+        this.announceConnection(channelId, senderId)
+        break
+      default:
+        this.emit("message", {
+          channelId,
+          senderId,
+          targetId,
+          message: new Uint8Array(messageData),
+          broadcast,
+        })
+    }
+  }
+}

package/src/NodeWSServerAdapter.ts

@@ -0,0 +1,143 @@
+import * as CBOR from "cbor-x"
+import { WebSocket, type WebSocketServer } from "isomorphic-ws"
+
+import debug from "debug"
+const log = debug("WebsocketServer")
+
+import {
+  ChannelId,
+  InboundMessagePayload,
+  NetworkAdapter,
+  PeerId,
+} from "@automerge/automerge-repo"
+
+export class NodeWSServerAdapter extends NetworkAdapter {
+  server: WebSocketServer
+  sockets: { [peerId: PeerId]: WebSocket } = {}
+
+  constructor(server: WebSocketServer) {
+    super()
+    this.server = server
+  }
+
+  connect(peerId: PeerId) {
+    this.peerId = peerId
+    this.server.on("connection", socket => {
+      // 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]
+          }
+        }
+      })
+
+      socket.on("message", message =>
+        this.receiveMessage(message as Uint8Array, socket)
+      )
+    })
+  }
+
+  join(docId: ChannelId) {
+    // throw new Error("The server doesn't join channels.")
+  }
+
+  leave(docId: ChannelId) {
+    // throw new Error("The server doesn't join channels.")
+  }
+
+  sendMessage(
+    targetId: PeerId,
+    channelId: ChannelId,
+    message: Uint8Array,
+    broadcast: boolean
+  ) {
+    if (message.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.")
+    }
+    if (this.sockets[targetId] === undefined) {
+      log(`Tried to send message to disconnected peer: ${targetId}`)
+      return
+    }
+
+    const decoded: InboundMessagePayload = {
+      senderId,
+      targetId,
+      channelId,
+      type: "sync",
+      message,
+      broadcast,
+    }
+    const encoded = CBOR.encode(decoded)
+
+    // 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
+    )
+
+    log(
+      `[${senderId}->${targetId}@${channelId}] "sync" | ${arrayBuf.byteLength} bytes`
+    )
+
+    this.sockets[targetId].send(arrayBuf)
+  }
+
+  receiveMessage(message: Uint8Array, socket: WebSocket) {
+    const cbor: InboundMessagePayload = CBOR.decode(message)
+
+    const {
+      type,
+      channelId,
+      senderId,
+      targetId,
+      message: data,
+      broadcast,
+    } = cbor
+
+    const myPeerId = this.peerId
+    if (!myPeerId) {
+      throw new Error("Missing my peer ID.")
+    }
+    log(
+      `[${senderId}->${myPeerId}@${channelId}] ${type} | ${message.byteLength} bytes`
+    )
+    switch (type) {
+      case "join":
+        // Let the rest of the system know that we have a new connection.
+        this.emit("peer-candidate", { peerId: senderId, channelId })
+        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)
+        socket.send(
+          CBOR.encode({ type: "peer", senderId: this.peerId, channelId })
+        )
+        break
+      case "leave":
+        // It doesn't seem like this gets called;
+        // we handle leaving in the socket close logic
+        // TODO: confirm this
+        // ?
+        break
+      case "message":
+        this.emit("message", {
+          senderId,
+          targetId,
+          channelId,
+          message: new Uint8Array(data),
+          broadcast,
+        })
+        break
+      default:
+        // log("unrecognized message type")
+        break
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { BrowserWebSocketClientAdapter } from "./BrowserWebSocketClientAdapter.js"
+export { NodeWSServerAdapter } from "./NodeWSServerAdapter.js"

package/test/Websocket.test.ts

@@ -0,0 +1,25 @@
+import { runAdapterTests } from "@automerge/automerge-repo"
+import { BrowserWebSocketClientAdapter } from "../src/BrowserWebSocketClientAdapter"
+import { NodeWSServerAdapter } from "../src/NodeWSServerAdapter"
+import { startServer } from "./utilities/WebSockets"
+
+describe("Websocket adapters", async () => {
+  let port = 8080
+
+  runAdapterTests(async () => {
+    port += 1 // Increment port to avoid conflicts
+    const { socket, server } = await startServer(port)
+    const serverAdapter = new NodeWSServerAdapter(socket)
+
+    const serverUrl = `ws://localhost:${port}`
+
+    const aliceAdapter = new BrowserWebSocketClientAdapter(serverUrl)
+    const bobAdapter = new BrowserWebSocketClientAdapter(serverUrl)
+
+    const teardown = () => {
+      server.close()
+    }
+
+    return { adapters: [serverAdapter, aliceAdapter, bobAdapter], teardown }
+  })
+})

package/test/utilities/CreateWebSocketServer.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,34 @@
+import http from "http"
+import { createWebSocketServer } from "./CreateWebSocketServer"
+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 }

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "jsx": "react",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"]
+}