cojson 0.0.8 → 0.0.10

package/src/sync.test.ts

@@ -980,6 +980,123 @@ test("Can sync a coValue with private transactions through a server to another c
     );
 });
 
+test("When a peer's incoming/readable stream closes, we remove the peer", async () => {
+    const admin = newRandomAgentCredential("admin");
+    const adminID = getAgentID(getAgent(admin));
+
+    const node = new LocalNode(admin, newRandomSessionID(adminID));
+
+    const team = node.createTeam();
+
+    const [inRx, inTx] = newStreamPair<SyncMessage>();
+    const [outRx, outTx] = newStreamPair<SyncMessage>();
+
+    node.sync.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "server",
+    });
+
+    const reader = outRx.getReader();
+    expect((await reader.read()).value).toMatchObject({
+        action: "subscribe",
+        coValueID: adminID,
+    });
+    expect((await reader.read()).value).toMatchObject({
+        action: "subscribe",
+        coValueID: team.teamMap.coValue.id,
+    });
+
+    const map = team.createMap();
+
+    const mapSubscribeMsg = await reader.read();
+
+    expect(mapSubscribeMsg.value).toEqual({
+        action: "subscribe",
+        ...map.coValue.knownState(),
+    } satisfies SyncMessage);
+
+    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+
+    const mapContentMsg = await reader.read();
+
+    expect(mapContentMsg.value).toEqual({
+        action: "newContent",
+        coValueID: map.coValue.id,
+        header: map.coValue.header,
+        newContent: {},
+    } satisfies SyncMessage);
+
+    await inTx.abort();
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    expect(node.sync.peers["test"]).toBeUndefined();
+});
+
+test("When a peer's outgoing/writable stream closes, we remove the peer", async () => {
+    const admin = newRandomAgentCredential("admin");
+    const adminID = getAgentID(getAgent(admin));
+
+    const node = new LocalNode(admin, newRandomSessionID(adminID));
+
+    const team = node.createTeam();
+
+    const [inRx, inTx] = newStreamPair<SyncMessage>();
+    const [outRx, outTx] = newStreamPair<SyncMessage>();
+
+    node.sync.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "server",
+    });
+
+    const reader = outRx.getReader();
+    expect((await reader.read()).value).toMatchObject({
+        action: "subscribe",
+        coValueID: adminID,
+    });
+    expect((await reader.read()).value).toMatchObject({
+        action: "subscribe",
+        coValueID: team.teamMap.coValue.id,
+    });
+
+    const map = team.createMap();
+
+    const mapSubscribeMsg = await reader.read();
+
+    expect(mapSubscribeMsg.value).toEqual({
+        action: "subscribe",
+        ...map.coValue.knownState(),
+    } satisfies SyncMessage);
+
+    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+
+    const mapContentMsg = await reader.read();
+
+    expect(mapContentMsg.value).toEqual({
+        action: "newContent",
+        coValueID: map.coValue.id,
+        header: map.coValue.header,
+        newContent: {},
+    } satisfies SyncMessage);
+
+    reader.releaseLock();
+    await outRx.cancel();
+
+    map.edit((editable) => {
+        editable.set("hello", "world", "trusting");
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    expect(node.sync.peers["test"]).toBeUndefined();
+})
+
 function teamContentEx(team: Team) {
     return {
         action: "newContent",
@@ -1015,10 +1132,17 @@ function newStreamPair<T>(): [ReadableStream<T>, WritableStream<T>] {
         resolveNextItemReady = resolve;
     });
 
+    let writerClosed = false;
+    let readerClosed = false;
+
     const readable = new ReadableStream<T>({
         async pull(controller) {
             let retriesLeft = 3;
             while (retriesLeft > 0) {
+                if (writerClosed) {
+                    controller.close();
+                    return;
+                }
                 retriesLeft--;
                 if (queue.length > 0) {
                     controller.enqueue(queue.shift()!);
@@ -1034,16 +1158,31 @@ function newStreamPair<T>(): [ReadableStream<T>, WritableStream<T>] {
             }
             throw new Error("Should only use one retry to get next item in queue.")
         },
+
+        cancel(reason) {
+            console.log("Manually closing reader")
+            readerClosed = true;
+        },
     });
 
     const writable = new WritableStream<T>({
-        write(chunk) {
+        write(chunk, controller) {
+            if (readerClosed) {
+                console.log("Reader closed, not writing chunk", chunk);
+                throw new Error("Reader closed, not writing chunk");
+            }
             queue.push(chunk);
             if (queue.length === 1) {
                 // make sure that await write resolves before corresponding read
                 process.nextTick(() => resolveNextItemReady());
             }
         },
+        abort(reason) {
+            console.log("Manually closing writer")
+            writerClosed = true;
+            resolveNextItemReady();
+            return Promise.resolve();
+        },
     });
 
     return [readable, writable];

package/src/sync.ts

@@ -1,10 +1,14 @@
-import { Hash, Signature } from './crypto.js';
-import { CoValueHeader, Transaction } from './coValue.js';
-import { CoValue } from './coValue.js';
-import { LocalNode } from './node.js';
-import { newLoadingState } from './node.js';
-import { ReadableStream, WritableStream, WritableStreamDefaultWriter } from "isomorphic-streams";
-import { RawCoValueID, SessionID } from './ids.js';
+import { Hash, Signature } from "./crypto.js";
+import { CoValueHeader, Transaction } from "./coValue.js";
+import { CoValue } from "./coValue.js";
+import { LocalNode } from "./node.js";
+import { newLoadingState } from "./node.js";
+import {
+    ReadableStream,
+    WritableStream,
+    WritableStreamDefaultWriter,
+} from "isomorphic-streams";
+import { RawCoValueID, SessionID } from "./ids.js";
 
 export type CoValueKnownState = {
     coValueID: RawCoValueID;
@@ -162,7 +166,7 @@ export class SyncManager {
 
         if (!peer.toldKnownState.has(coValueID)) {
             peer.toldKnownState.add(coValueID);
-            await peer.outgoing.write({
+            await this.trySendToPeer(peer, {
                 action: "subscribe",
                 ...coValue.knownState(),
             });
@@ -185,7 +189,7 @@ export class SyncManager {
         }
 
         if (!peer.toldKnownState.has(coValueID)) {
-            await peer.outgoing.write({
+            await this.trySendToPeer(peer, {
                 action: "tellKnownState",
                 asDependencyOf,
                 ...coValue.knownState(),
@@ -210,7 +214,7 @@ export class SyncManager {
         );
 
         if (newContent) {
-            await peer.outgoing.write(newContent);
+            await this.trySendToPeer(peer, newContent);
             peer.optimisticKnownStates[coValueID] = combinedKnownStates(
                 peer.optimisticKnownStates[coValueID] ||
                     emptyKnownState(coValueID),
@@ -264,11 +268,20 @@ export class SyncManager {
                     );
                 }
             }
+            console.log("Peer disconnected:", peer.id);
+            delete this.peers[peer.id];
         };
 
         void readIncoming();
     }
 
+    trySendToPeer(peer: PeerState, msg: SyncMessage) {
+        return peer.outgoing.write(msg).catch((e) => {
+            console.error("Error writing to peer, disconnecting", e);
+            delete this.peers[peer.id];
+        });
+    }
+
     async handleSubscribe(msg: SubscribeMessage, peer: PeerState) {
         const entry = this.local.coValues[msg.coValueID];
 
@@ -280,7 +293,7 @@ export class SyncManager {
             peer.optimisticKnownStates[msg.coValueID] = knownStateIn(msg);
             peer.toldKnownState.add(msg.coValueID);
 
-            await peer.outgoing.write({
+            await this.trySendToPeer(peer, {
                 action: "tellKnownState",
                 coValueID: msg.coValueID,
                 header: false,
@@ -304,7 +317,8 @@ export class SyncManager {
         let entry = this.local.coValues[msg.coValueID];
 
         peer.optimisticKnownStates[msg.coValueID] = combinedKnownStates(
-            peer.optimisticKnownStates[msg.coValueID] || emptyKnownState(msg.coValueID),
+            peer.optimisticKnownStates[msg.coValueID] ||
+                emptyKnownState(msg.coValueID),
             knownStateIn(msg)
         );
 
@@ -423,7 +437,7 @@ export class SyncManager {
         await this.syncCoValue(coValue);
 
         if (invalidStateAssumed) {
-            await peer.outgoing.write({
+            await this.trySendToPeer(peer, {
                 action: "wrongAssumedKnownState",
                 ...coValue.knownState(),
             });
@@ -444,7 +458,7 @@ export class SyncManager {
         const newContent = coValue.newContentSince(msg);
 
         if (newContent) {
-            await peer.outgoing.write(newContent);
+            await this.trySendToPeer(peer, newContent);
         }
     }
 
@@ -466,10 +480,7 @@ export class SyncManager {
                     peer
                 );
             } else if (peer.role === "server") {
-                await this.subscribeToIncludingDependencies(
-                    coValue.id,
-                    peer
-                );
+                await this.subscribeToIncludingDependencies(coValue.id, peer);
                 await this.sendNewContentIncludingDependencies(
                     coValue.id,
                     peer