cojson 0.0.9 → 0.0.11

package/src/sync.test.ts

@@ -980,6 +980,155 @@ 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();
+})
+
+test("If we start loading a coValue before connecting to a peer that has it, it will load it once we connect", async () => {
+    const admin = newRandomAgentCredential("admin");
+    const adminID = getAgentID(getAgent(admin));
+
+    const node1 = new LocalNode(admin, newRandomSessionID(adminID));
+
+    const team = node1.createTeam();
+
+    const map = team.createMap();
+    map.edit((editable) => {
+        editable.set("hello", "world", "trusting");
+    });
+
+    const node2 = new LocalNode(admin, newRandomSessionID(adminID));
+
+    const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2", {peer1role: 'server', peer2role: 'client', trace: true});
+
+    node1.sync.addPeer(node2asPeer);
+
+    const mapOnNode2Promise = node2.loadCoValue(map.coValue.id);
+
+    expect(node2.coValues[map.coValue.id]?.state).toEqual("loading");
+
+    node2.sync.addPeer(node1asPeer);
+
+    const mapOnNode2 = await mapOnNode2Promise;
+
+    expect(expectMap(mapOnNode2.getCurrentContent()).get("hello")).toEqual(
+        "world"
+    );
+})
+
 function teamContentEx(team: Team) {
     return {
         action: "newContent",
@@ -1015,10 +1164,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 +1190,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;
@@ -154,7 +158,25 @@ export class SyncManager {
         coValueID: RawCoValueID,
         peer: PeerState
     ) {
-        const coValue = this.local.expectCoValueLoaded(coValueID);
+        const entry = this.local.coValues[coValueID];
+
+        if (!entry) {
+            throw new Error(
+                "Expected coValue entry on subscribe"
+            );
+        }
+
+        if (entry.state === "loading") {
+            await this.trySendToPeer(peer, {
+                action: "subscribe",
+                coValueID,
+                header: false,
+                sessions: {},
+            });
+            return;
+        }
+
+        const coValue = entry.coValue;
 
         for (const coValueID of coValue.getDependedOnCoValues()) {
             await this.subscribeToIncludingDependencies(coValueID, peer);
@@ -162,7 +184,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 +207,7 @@ export class SyncManager {
         }
 
         if (!peer.toldKnownState.has(coValueID)) {
-            await peer.outgoing.write({
+            await this.trySendToPeer(peer, {
                 action: "tellKnownState",
                 asDependencyOf,
                 ...coValue.knownState(),
@@ -210,7 +232,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),
@@ -232,18 +254,13 @@ export class SyncManager {
 
         if (peer.role === "server") {
             const initialSync = async () => {
-                for (const entry of Object.values(this.local.coValues)) {
-                    if (entry.state === "loading") {
-                        continue;
-                    }
-
-                    await this.subscribeToIncludingDependencies(
-                        entry.coValue.id,
-                        peerState
-                    );
+                for (const id of Object.keys(
+                    this.local.coValues
+                ) as RawCoValueID[]) {
+                    await this.subscribeToIncludingDependencies(id, peerState);
 
-                    peerState.optimisticKnownStates[entry.coValue.id] = {
-                        coValueID: entry.coValue.id,
+                    peerState.optimisticKnownStates[id] = {
+                        coValueID: id,
                         header: false,
                         sessions: {},
                     };
@@ -264,11 +281,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 +306,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 +330,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 +450,7 @@ export class SyncManager {
         await this.syncCoValue(coValue);
 
         if (invalidStateAssumed) {
-            await peer.outgoing.write({
+            await this.trySendToPeer(peer, {
                 action: "wrongAssumedKnownState",
                 ...coValue.knownState(),
             });
@@ -444,7 +471,7 @@ export class SyncManager {
         const newContent = coValue.newContentSince(msg);
 
         if (newContent) {
-            await peer.outgoing.write(newContent);
+            await this.trySendToPeer(peer, newContent);
         }
     }
 
@@ -466,10 +493,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