cojson 0.20.9 → 0.20.11

package/src/tests/StorageReconciliationAckTracker.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test, vi } from "vitest";
+import { PeerState } from "../PeerState.js";
+import { StorageReconciliationServerAckTracker } from "../StorageReconciliationAckTracker.js";
+import { ConnectedPeerChannel } from "../streamUtils.js";
+import { Peer } from "../sync.js";
+
+function createPeerState(id = "peer-1"): PeerState {
+  const peer: Peer = {
+    id,
+    role: "server",
+    persistent: true,
+    incoming: new ConnectedPeerChannel(),
+    outgoing: new ConnectedPeerChannel(),
+  };
+
+  return new PeerState(peer, undefined);
+}
+
+describe("StorageReconciliationAckTracker", () => {
+  test("tracks pending acks and returns next offset on ack", () => {
+    const tracker = new StorageReconciliationServerAckTracker();
+
+    tracker.trackBatch("batch-1", "peer-1", 100);
+
+    expect(tracker.pendingReconciliationAck.get("batch-1#peer-1")).toBe(100);
+
+    const nextOffset = tracker.handleAck("batch-1", "peer-1");
+
+    expect(nextOffset).toBe(100);
+    expect(tracker.pendingReconciliationAck.has("batch-1#peer-1")).toBe(false);
+  });
+
+  test("invokes registered callback when ack is received", () => {
+    const tracker = new StorageReconciliationServerAckTracker();
+    const peer = createPeerState("peer-1");
+    const onAck = vi.fn();
+
+    tracker.trackBatch("batch-1", peer.id, 50);
+    tracker.waitForAck("batch-1", peer, onAck);
+
+    expect(onAck).not.toHaveBeenCalled();
+
+    tracker.handleAck("batch-1", peer.id);
+
+    expect(onAck).toHaveBeenCalledTimes(1);
+  });
+
+  test("invokes callback only once even if peer closes after ack", () => {
+    const tracker = new StorageReconciliationServerAckTracker();
+    const peer = createPeerState("peer-1");
+    const onAck = vi.fn();
+
+    tracker.trackBatch("batch-1", peer.id, 50);
+    tracker.waitForAck("batch-1", peer, onAck);
+    tracker.handleAck("batch-1", peer.id);
+    peer.gracefulShutdown();
+
+    expect(onAck).toHaveBeenCalledTimes(1);
+  });
+
+  test("invokes all listeners registered for a batch", () => {
+    const tracker = new StorageReconciliationServerAckTracker();
+    const peer = createPeerState("peer-1");
+    const first = vi.fn();
+    const second = vi.fn();
+
+    tracker.trackBatch("batch-1", peer.id, 50);
+    tracker.waitForAck("batch-1", peer, first);
+    tracker.waitForAck("batch-1", peer, second);
+    tracker.handleAck("batch-1", peer.id);
+
+    expect(first).toHaveBeenCalledTimes(1);
+    expect(second).toHaveBeenCalledTimes(1);
+  });
+
+  test("calls callback immediately when batch is not pending", () => {
+    const tracker = new StorageReconciliationServerAckTracker();
+    const peer = createPeerState("peer-1");
+    const onAck = vi.fn();
+
+    tracker.waitForAck("missing-batch", peer, onAck);
+
+    expect(onAck).toHaveBeenCalledTimes(1);
+  });
+
+  test("aborts wait on peer close and clears pending ack", () => {
+    const tracker = new StorageReconciliationServerAckTracker();
+    const peer = createPeerState("peer-1");
+    const onAck = vi.fn();
+
+    tracker.trackBatch("batch-1", peer.id, 50);
+    tracker.waitForAck("batch-1", peer, onAck);
+
+    peer.gracefulShutdown();
+
+    expect(onAck).not.toHaveBeenCalled();
+    expect(tracker.pendingReconciliationAck.has("batch-1#peer-1")).toBe(false);
+  });
+});

package/src/tests/SyncStateManager.test.ts

@@ -128,6 +128,31 @@ describe("SyncStateManager", () => {
     expect(subscriptionManager.isSynced(peerState, map.core.id)).toBe(true);
   });
 
+  test("isSynced should stay true for garbageCollected CoValues with matching knownState", async () => {
+    const client = setupTestNode({ connected: false });
+    client.addStorage({ ourName: "client" });
+    const { peerState } = client.connectToSyncServer();
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    const syncState = client.node.syncManager.syncState;
+
+    await waitFor(() => syncState.isSynced(peerState, map.core.id));
+    expect(syncState.isSynced(peerState, map.core.id)).toBe(true);
+
+    const mapCore = client.node.getCoValue(map.id);
+    const mapKnownState = mapCore.knownState();
+    client.node.internalDeleteCoValue(map.id);
+
+    const garbageCollectedMap = client.node.getCoValue(map.id);
+    garbageCollectedMap.setGarbageCollectedState(mapKnownState);
+    expect(garbageCollectedMap.loadingState).toBe("garbageCollected");
+
+    expect(syncState.isSynced(peerState, map.core.id)).toBe(true);
+  });
+
   test("unsubscribe stops receiving updates", async () => {
     // Setup nodes
     const client = setupTestNode({ connected: true });

package/src/tests/coList.test.ts

@@ -5,6 +5,7 @@ import {
   hotSleep,
   loadCoValueOrFail,
   nodeWithRandomAgentAndSessionID,
+  setupTestAccount,
   setupTestNode,
   waitFor,
 } from "./testUtils.js";
@@ -1024,6 +1025,143 @@ test("the list should rebuild when the group permissions change", async () => {
   expect(listOnBob.totalValidTransactions).toEqual(1);
 });
 
+describe("CoList restricted deletion", () => {
+  test("default ownedByGroup behavior is unchanged (writers can delete)", async () => {
+    const alice = await setupTestAccount({ connected: true });
+    const bob = await setupTestAccount({ connected: true });
+
+    const group = alice.node.createGroup();
+    group.addMember(bob.account, "writer");
+
+    const listCore = alice.node.createCoValue({
+      type: "colist",
+      ruleset: { type: "ownedByGroup", group: group.id },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+    const list = expectList(listCore.getCurrentContent());
+    list.append("item");
+
+    const listOnBob = await loadCoValueOrFail(bob.node, list.id);
+    listOnBob.delete(0);
+
+    await waitFor(() => {
+      expect(list.toJSON()).toEqual([]);
+    });
+  });
+
+  test("with restrictDeletion enabled, writers can append but cannot delete or replace", async () => {
+    const alice = await setupTestAccount({ connected: true });
+    const bob = await setupTestAccount({ connected: true });
+
+    const group = alice.node.createGroup();
+    group.addMember(bob.account, "writer");
+
+    const listCore = alice.node.createCoValue({
+      type: "colist",
+      ruleset: {
+        type: "ownedByGroup",
+        group: group.id,
+        restrictDeletion: true,
+      },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+    const list = expectList(listCore.getCurrentContent());
+    list.append("seed");
+
+    const listOnBob = await loadCoValueOrFail(bob.node, list.id);
+
+    listOnBob.append("writer-append");
+    await waitFor(() => {
+      expect(list.toJSON()).toEqual(["seed", "writer-append"]);
+    });
+
+    listOnBob.delete(0);
+    await waitFor(() => {
+      expect(list.toJSON()).toEqual(["seed", "writer-append"]);
+    });
+
+    listOnBob.replace(1, "writer-replace-attempt");
+    await waitFor(() => {
+      expect(list.toJSON()).toEqual(["seed", "writer-append"]);
+    });
+  });
+
+  test("with restrictDeletion enabled, managers and admins can delete", async () => {
+    const alice = await setupTestAccount({ connected: true });
+    const bob = await setupTestAccount({ connected: true });
+
+    const group = alice.node.createGroup();
+    group.addMember(bob.account, "manager");
+
+    const listCore = alice.node.createCoValue({
+      type: "colist",
+      ruleset: {
+        type: "ownedByGroup",
+        group: group.id,
+        restrictDeletion: true,
+      },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+    const list = expectList(listCore.getCurrentContent());
+    list.appendItems(["first", "second", "third"]);
+
+    const listOnBob = await loadCoValueOrFail(bob.node, list.id);
+    listOnBob.delete(1);
+
+    await waitFor(() => {
+      expect(list.toJSON()).toEqual(["first", "third"]);
+    });
+
+    list.delete(0);
+    await waitFor(() => {
+      expect(list.toJSON()).toEqual(["third"]);
+    });
+  });
+
+  test("deletions made while writer stay blocked after promotion", async () => {
+    const alice = await setupTestAccount({ connected: true });
+    const bob = await setupTestAccount({ connected: true });
+
+    const group = alice.node.createGroup();
+    group.addMember(bob.account, "writer");
+
+    const listCore = alice.node.createCoValue({
+      type: "colist",
+      ruleset: {
+        type: "ownedByGroup",
+        group: group.id,
+        restrictDeletion: true,
+      },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+    const list = expectList(listCore.getCurrentContent());
+    list.append("item");
+
+    const listOnBob = await loadCoValueOrFail(bob.node, list.id);
+    listOnBob.delete(0);
+
+    await waitFor(() => {
+      expect(list.toJSON()).toEqual(["item"]);
+    });
+
+    group.addMember(bob.account, "manager");
+
+    await waitFor(() => {
+      expect(list.toJSON()).toEqual(["item"]);
+      expect(listOnBob.toJSON()).toEqual(["item"]);
+    });
+
+    listOnBob.delete(0);
+    await waitFor(() => {
+      expect(list.toJSON()).toEqual([]);
+    });
+  });
+});
+
 test("items appended after a losing init transaction are preserved", async () => {
   const alice = setupTestNode({ connected: true });
   const bob = setupTestNode({ connected: true });

package/src/tests/coValueCore.loadFromStorage.test.ts

@@ -1,7 +1,10 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { RawCoID } from "../ids";
 import { PeerID } from "../sync";
-import { StorageAPI } from "../storage/types";
+import type {
+  StorageAPI,
+  StorageReconciliationAcquireResult,
+} from "../storage/types";
 import {
   createTestMetricReader,
   createTestNode,
@@ -29,6 +32,12 @@ function setup() {
 
 function createMockStorage(
   opts: {
+    getCoValueIDs?: (
+      limit: number,
+      offset: number,
+      callback: (batch: { id: RawCoID }[]) => void,
+    ) => void;
+    getCoValueCount?: (callback: (count: number) => void) => void;
     load?: (
       id: RawCoID,
       callback: (data: any) => void,
@@ -50,9 +59,26 @@ function createMockStorage(
     markDeleteAsValid?: (id: RawCoID) => void;
     enableDeletedCoValuesErasure?: () => void;
     eraseAllDeletedCoValues?: () => Promise<void>;
+    tryAcquireStorageReconciliationLock?: (
+      sessionId: string,
+      peerId: string,
+      callback: (result: StorageReconciliationAcquireResult) => void,
+    ) => void;
+    renewStorageReconciliationLock?: (
+      sessionId: string,
+      peerId: string,
+      offset: number,
+    ) => void;
+    releaseStorageReconciliationLock?: (
+      sessionId: string,
+      peerId: string,
+      callback?: () => void,
+    ) => void;
   } = {},
 ): StorageAPI {
   return {
+    getCoValueIDs: opts.getCoValueIDs || vi.fn(),
+    getCoValueCount: opts.getCoValueCount || vi.fn(),
     markDeleteAsValid: opts.markDeleteAsValid || vi.fn(),
     enableDeletedCoValuesErasure: opts.enableDeletedCoValuesErasure || vi.fn(),
     eraseAllDeletedCoValues: opts.eraseAllDeletedCoValues || vi.fn(),
@@ -67,6 +93,15 @@ function createMockStorage(
     stopTrackingSyncState: opts.stopTrackingSyncState || vi.fn(),
     onCoValueUnmounted: opts.onCoValueUnmounted || vi.fn(),
     close: opts.close || vi.fn().mockResolvedValue(undefined),
+    tryAcquireStorageReconciliationLock:
+      opts.tryAcquireStorageReconciliationLock ||
+      vi.fn((_sessionId, _peerId, callback) =>
+        callback({ acquired: false as const, reason: "not_due" as const }),
+      ),
+    renewStorageReconciliationLock:
+      opts.renewStorageReconciliationLock || vi.fn(),
+    releaseStorageReconciliationLock:
+      opts.releaseStorageReconciliationLock || vi.fn(),
   };
 }
 
@@ -518,6 +553,22 @@ describe("CoValueCore.loadFromStorage", () => {
 
       expect(loadSpy).toHaveBeenCalledTimes(1);
     });
+
+    test("should keep garbageCollected loadingState even when a peer is pending", () => {
+      const { state, node, id } = setup();
+      const storage = createMockStorage();
+      node.setStorage(storage);
+
+      state.setGarbageCollectedState({
+        id,
+        header: true,
+        sessions: {},
+      });
+      state.markPending("peer1");
+
+      expect(state.getLoadingStateForPeer("peer1")).toBe("pending");
+      expect(state.loadingState).toBe("garbageCollected");
+    });
   });
 
   describe("when state is onlyKnownState", () => {
@@ -576,6 +627,26 @@ describe("CoValueCore.loadFromStorage", () => {
 
       expect(loadSpy).toHaveBeenCalledTimes(1);
     });
+
+    test("should keep onlyKnownState loadingState even when a peer is pending", () => {
+      const { state, node, id } = setup();
+      const storage = createMockStorage({
+        loadKnownState: (id, callback) => {
+          callback({
+            id,
+            header: true,
+            sessions: { session1: 1 },
+          });
+        },
+      });
+      node.setStorage(storage);
+
+      state.getKnownStateFromStorage(() => {});
+      state.markPending("peer1");
+
+      expect(state.getLoadingStateForPeer("peer1")).toBe("pending");
+      expect(state.loadingState).toBe("onlyKnownState");
+    });
   });
 
   describe("edge cases and integration", () => {

package/src/tests/group.test.ts

@@ -435,6 +435,93 @@ test("Should heal the missing key_for_everyone", async () => {
   );
 });
 
+describe("reader cannot create content", () => {
+  test("createMap throws for reader", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "reader",
+    );
+
+    await group.core.waitForSync();
+
+    const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
+    expect(groupOnNode2.myRole()).toBe("reader");
+    expect(() => groupOnNode2.createMap()).toThrow(
+      "does not have write permissions",
+    );
+  });
+
+  test("createList throws for reader", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "reader",
+    );
+
+    await group.core.waitForSync();
+
+    const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
+    expect(() => groupOnNode2.createList()).toThrow(
+      "does not have write permissions",
+    );
+  });
+
+  test("createStream throws for reader", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "reader",
+    );
+
+    await group.core.waitForSync();
+
+    const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
+    expect(() => groupOnNode2.createStream()).toThrow(
+      "does not have write permissions",
+    );
+  });
+
+  test("createBinaryStream throws for reader", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "reader",
+    );
+
+    await group.core.waitForSync();
+
+    const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
+    expect(() => groupOnNode2.createBinaryStream()).toThrow(
+      "does not have write permissions",
+    );
+  });
+
+  test("writer can still create content", async () => {
+    const { node1, node2 } = await createTwoConnectedNodes("server", "server");
+
+    const group = node1.node.createGroup();
+    group.addMember(
+      await loadCoValueOrFail(node1.node, node2.accountID),
+      "writer",
+    );
+
+    await group.core.waitForSync();
+
+    const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
+    const map = groupOnNode2.createMap();
+    expect(map.type).toBe("comap");
+  });
+});
+
 describe("writeOnly", () => {
   test("Admins can invite writeOnly members", async () => {
     const { node1, node2 } = await createTwoConnectedNodes("server", "server");

package/src/tests/knownState.lazyLoading.test.ts

@@ -1,12 +1,21 @@
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { RawCoID, SessionID } from "../ids";
 import { PeerID } from "../sync";
-import { StorageAPI } from "../storage/types";
+import type {
+  StorageAPI,
+  StorageReconciliationAcquireResult,
+} from "../storage/types";
 import { CoValueKnownState, peerHasAllContent } from "../knownState";
 import { createTestNode, createUnloadedCoValue } from "./testUtils";
 
 function createMockStorage(
   opts: {
+    getCoValueIDs?: (
+      limit: number,
+      offset: number,
+      callback: (batch: { id: RawCoID }[]) => void,
+    ) => void;
+    getCoValueCount?: (callback: (count: number) => void) => void;
     load?: (
       id: RawCoID,
       callback: (data: any) => void,
@@ -28,9 +37,26 @@ function createMockStorage(
     markDeleteAsValid?: (id: RawCoID) => void;
     enableDeletedCoValuesErasure?: () => void;
     eraseAllDeletedCoValues?: () => Promise<void>;
+    tryAcquireStorageReconciliationLock?: (
+      sessionId: string,
+      peerId: string,
+      callback: (result: StorageReconciliationAcquireResult) => void,
+    ) => void;
+    renewStorageReconciliationLock?: (
+      sessionId: string,
+      peerId: string,
+      offset: number,
+    ) => void;
+    releaseStorageReconciliationLock?: (
+      sessionId: string,
+      peerId: string,
+      callback?: () => void,
+    ) => void;
   } = {},
 ): StorageAPI {
   return {
+    getCoValueIDs: opts.getCoValueIDs || vi.fn(),
+    getCoValueCount: opts.getCoValueCount || vi.fn(),
     markDeleteAsValid: opts.markDeleteAsValid || vi.fn(),
     enableDeletedCoValuesErasure: opts.enableDeletedCoValuesErasure || vi.fn(),
     eraseAllDeletedCoValues: opts.eraseAllDeletedCoValues || vi.fn(),
@@ -45,6 +71,15 @@ function createMockStorage(
     stopTrackingSyncState: opts.stopTrackingSyncState || vi.fn(),
     onCoValueUnmounted: opts.onCoValueUnmounted || vi.fn(),
     close: opts.close || vi.fn().mockResolvedValue(undefined),
+    tryAcquireStorageReconciliationLock:
+      opts.tryAcquireStorageReconciliationLock ||
+      vi.fn((_sessionId, _peerId, callback) =>
+        callback({ acquired: false as const, reason: "not_due" as const }),
+      ),
+    renewStorageReconciliationLock:
+      opts.renewStorageReconciliationLock || vi.fn(),
+    releaseStorageReconciliationLock:
+      opts.releaseStorageReconciliationLock || vi.fn(),
   };
 }
 

package/src/tests/messagesTestUtils.ts

@@ -60,6 +60,10 @@ export function toSimplifiedMessages(
         return `${from} -> ${to} | GET_KNOWN_STATE ${getCoValue(msg.id)}`;
       case "lazyLoadResult":
         return `${from} -> ${to} | GET_KNOWN_STATE_RESULT ${getCoValue(msg.id)} sessions: ${simplifySessions(msg)}`;
+      case "reconcile":
+        return `${from} -> ${to} | RECONCILE`;
+      case "reconcile-ack":
+        return `${from} -> ${to} | RECONCILE_ACK`;
     }
   }