cojson 0.18.27 → 0.18.28

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

@@ -0,0 +1,540 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { RawCoID } from "../ids";
+import { StorageAPI } from "../storage/types";
+import {
+  createTestMetricReader,
+  createTestNode,
+  createUnloadedCoValue,
+  tearDownTestMetricReader,
+} from "./testUtils";
+
+let metricReader: ReturnType<typeof createTestMetricReader>;
+
+beforeEach(() => {
+  metricReader = createTestMetricReader();
+});
+
+afterEach(() => {
+  tearDownTestMetricReader();
+});
+
+function setup() {
+  const node = createTestNode();
+
+  const { coValue, id, header } = createUnloadedCoValue(node);
+
+  return { node, state: coValue, id, header };
+}
+
+function createMockStorage(
+  opts: {
+    load?: (
+      id: RawCoID,
+      callback: (data: any) => void,
+      done: (found: boolean) => void,
+    ) => void;
+    store?: (data: any, correctionCallback: any) => void;
+    getKnownState?: (id: RawCoID) => any;
+    waitForSync?: (id: string, coValue: any) => Promise<void>;
+    close?: () => Promise<unknown> | undefined;
+  } = {},
+): StorageAPI {
+  return {
+    load: opts.load || vi.fn(),
+    store: opts.store || vi.fn(),
+    getKnownState: opts.getKnownState || vi.fn(),
+    waitForSync: opts.waitForSync || vi.fn().mockResolvedValue(undefined),
+    close: opts.close || vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+describe("CoValueCore.loadFromStorage", () => {
+  describe("when storage is not configured", () => {
+    test("should call done callback with false immediately", () => {
+      const { state } = setup();
+      const doneSpy = vi.fn();
+
+      state.loadFromStorage(doneSpy);
+
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+      expect(doneSpy).toHaveBeenCalledWith(false);
+    });
+
+    test("should not crash when done callback is not provided", () => {
+      const { state } = setup();
+
+      expect(() => state.loadFromStorage()).not.toThrow();
+    });
+  });
+
+  describe("when current state is pending", () => {
+    test("should return early when done callback is not provided", () => {
+      const { state, node } = setup();
+      const loadSpy = vi.fn();
+      const storage = createMockStorage({ load: loadSpy });
+      node.setStorage(storage);
+
+      // Mark as pending
+      state.markPending("storage");
+
+      // Call without done callback
+      state.loadFromStorage();
+
+      // Should not call storage.load again
+      expect(loadSpy).not.toHaveBeenCalled();
+    });
+
+    test("should wait for loading to complete and call done(true) when becomes available", async () => {
+      const { state, node, header } = setup();
+      let storageCallback: any;
+      let storageDone: any;
+
+      const storage = createMockStorage({
+        load: (id, callback, done) => {
+          storageCallback = callback;
+          storageDone = done;
+        },
+      });
+      node.setStorage(storage);
+
+      // Start initial load (will mark as pending)
+      state.loadFromStorage();
+
+      // Now try to load again with a done callback while pending
+      const doneSpy = vi.fn();
+      state.loadFromStorage(doneSpy);
+
+      // Should not call done yet
+      expect(doneSpy).not.toHaveBeenCalled();
+
+      // Simulate storage providing header and marking as found
+      const previousState = state.loadingState;
+      state.provideHeader(header);
+      state.markFoundInPeer("storage", previousState);
+
+      // Wait a tick for subscription to fire
+      await new Promise((resolve) => setImmediate(resolve));
+
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+      expect(doneSpy).toHaveBeenCalledWith(true);
+    });
+
+    test("should wait for loading to complete and call done(false) when becomes errored", async () => {
+      const { state, node } = setup();
+      const storage = createMockStorage({
+        load: vi.fn(),
+      });
+      node.setStorage(storage);
+
+      // Start initial load (will mark as pending)
+      state.loadFromStorage();
+
+      // Now try to load again with a done callback while pending
+      const doneSpy = vi.fn();
+      state.loadFromStorage(doneSpy);
+
+      // Should not call done yet
+      expect(doneSpy).not.toHaveBeenCalled();
+
+      // Simulate error
+      state.markErrored("storage", {} as any);
+
+      // Wait a tick for subscription to fire
+      await new Promise((resolve) => setImmediate(resolve));
+
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+      expect(doneSpy).toHaveBeenCalledWith(false);
+    });
+
+    test("should wait for loading to complete and call done(false) when becomes unavailable", async () => {
+      const { state, node } = setup();
+      const storage = createMockStorage({
+        load: vi.fn(),
+      });
+      node.setStorage(storage);
+
+      // Start initial load (will mark as pending)
+      state.loadFromStorage();
+
+      // Now try to load again with a done callback while pending
+      const doneSpy = vi.fn();
+      state.loadFromStorage(doneSpy);
+
+      // Should not call done yet
+      expect(doneSpy).not.toHaveBeenCalled();
+
+      // Simulate not found
+      state.markNotFoundInPeer("storage");
+
+      // Wait a tick for subscription to fire
+      await new Promise((resolve) => setImmediate(resolve));
+
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+      expect(doneSpy).toHaveBeenCalledWith(false);
+    });
+
+    test("should unsubscribe after receiving result", async () => {
+      const { state, node, header } = setup();
+      const storage = createMockStorage({
+        load: vi.fn(),
+      });
+      node.setStorage(storage);
+
+      // Start initial load (will mark as pending)
+      state.loadFromStorage();
+
+      // Now try to load again with a done callback while pending
+      const doneSpy = vi.fn();
+      state.loadFromStorage(doneSpy);
+
+      // Simulate becoming available
+      const previousState = state.loadingState;
+      state.provideHeader(header);
+      state.markFoundInPeer("storage", previousState);
+
+      // Wait a tick for subscription to fire
+      await new Promise((resolve) => setImmediate(resolve));
+
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+
+      // Further state changes should not trigger the callback again
+      state.markNotFoundInPeer("another_peer");
+      await new Promise((resolve) => setImmediate(resolve));
+
+      expect(doneSpy).toHaveBeenCalledTimes(1); // Still only called once
+    });
+  });
+
+  describe("when current state is not unknown", () => {
+    test("should call done(true) immediately when state is available", () => {
+      const { state, node, header } = setup();
+      const storage = createMockStorage();
+      node.setStorage(storage);
+
+      // Mark as available
+      const previousState = state.loadingState;
+      state.provideHeader(header);
+      state.markFoundInPeer("storage", previousState);
+
+      const doneSpy = vi.fn();
+      state.loadFromStorage(doneSpy);
+
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+      expect(doneSpy).toHaveBeenCalledWith(true);
+    });
+
+    test("should call done(false) immediately when state is unavailable", () => {
+      const { state, node } = setup();
+      const storage = createMockStorage();
+      node.setStorage(storage);
+
+      // Mark as unavailable
+      state.markNotFoundInPeer("storage");
+
+      const doneSpy = vi.fn();
+      state.loadFromStorage(doneSpy);
+
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+      expect(doneSpy).toHaveBeenCalledWith(false);
+    });
+
+    test("should call done(false) immediately when state is errored", () => {
+      const { state, node } = setup();
+      const storage = createMockStorage();
+      node.setStorage(storage);
+
+      // Mark as errored
+      state.markErrored("storage", {} as any);
+
+      const doneSpy = vi.fn();
+      state.loadFromStorage(doneSpy);
+
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+      expect(doneSpy).toHaveBeenCalledWith(false);
+    });
+
+    test("should not call storage.load when state is already known", () => {
+      const { state, node, header } = setup();
+      const loadSpy = vi.fn();
+      const storage = createMockStorage({ load: loadSpy });
+      node.setStorage(storage);
+
+      // Mark as available
+      const previousState = state.loadingState;
+      state.provideHeader(header);
+      state.markFoundInPeer("storage", previousState);
+
+      state.loadFromStorage(vi.fn());
+
+      expect(loadSpy).not.toHaveBeenCalled();
+    });
+
+    test("should handle missing done callback when state is available", () => {
+      const { state, node, header } = setup();
+      const storage = createMockStorage();
+      node.setStorage(storage);
+
+      // Mark as available
+      const previousState = state.loadingState;
+      state.provideHeader(header);
+      state.markFoundInPeer("storage", previousState);
+
+      expect(() => state.loadFromStorage()).not.toThrow();
+    });
+  });
+
+  describe("when current state is unknown", () => {
+    test("should mark as pending and call storage.load", () => {
+      const { state, node, id } = setup();
+      const loadSpy = vi.fn();
+      const storage = createMockStorage({ load: loadSpy });
+      node.setStorage(storage);
+
+      state.loadFromStorage();
+
+      expect(state.getLoadingStateForPeer("storage")).toBe("pending");
+      expect(loadSpy).toHaveBeenCalledTimes(1);
+      expect(loadSpy).toHaveBeenCalledWith(
+        id,
+        expect.any(Function),
+        expect.any(Function),
+      );
+    });
+
+    test("should call done(true) when storage finds the value", async () => {
+      const { state, node, id, header } = setup();
+      let storageCallback: any;
+      let storageDone: any;
+
+      const storage = createMockStorage({
+        load: (id, callback, done) => {
+          storageCallback = callback;
+          storageDone = done;
+        },
+      });
+      node.setStorage(storage);
+
+      const doneSpy = vi.fn();
+      state.loadFromStorage(doneSpy);
+
+      // Simulate storage finding the value
+      // First provide the content through callback
+      state.provideHeader(header);
+
+      // Then call done with true
+      storageDone(true);
+
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+      expect(doneSpy).toHaveBeenCalledWith(true);
+    });
+
+    test("should call done(false) and mark as not found when storage doesn't find the value", async () => {
+      const { state, node } = setup();
+      let storageDone: any;
+
+      const storage = createMockStorage({
+        load: (id, callback, done) => {
+          storageDone = done;
+        },
+      });
+      node.setStorage(storage);
+
+      const doneSpy = vi.fn();
+      state.loadFromStorage(doneSpy);
+
+      // Simulate storage not finding the value
+      storageDone(false);
+
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+      expect(doneSpy).toHaveBeenCalledWith(false);
+      expect(state.getLoadingStateForPeer("storage")).toBe("unavailable");
+    });
+
+    test("should pass content to syncManager when storage provides it", async () => {
+      const { state, node } = setup();
+      let storageCallback: any;
+
+      const storage = createMockStorage({
+        load: (id, callback, done) => {
+          storageCallback = callback;
+        },
+      });
+      node.setStorage(storage);
+
+      const handleNewContentSpy = vi.spyOn(
+        node.syncManager,
+        "handleNewContent",
+      );
+
+      state.loadFromStorage();
+
+      // Simulate storage providing content with proper format
+      const mockData = {
+        action: "content" as const,
+        id: state.id,
+        priority: 0,
+        new: {},
+      };
+      storageCallback(mockData);
+
+      expect(handleNewContentSpy).toHaveBeenCalledTimes(1);
+      expect(handleNewContentSpy).toHaveBeenCalledWith(mockData, "storage");
+    });
+
+    test("should handle missing done callback when loading from storage", () => {
+      const { state, node } = setup();
+      let storageDone: any;
+
+      const storage = createMockStorage({
+        load: (id, callback, done) => {
+          storageDone = done;
+        },
+      });
+      node.setStorage(storage);
+
+      expect(() => {
+        state.loadFromStorage();
+        storageDone(true);
+      }).not.toThrow();
+    });
+
+    test("should not mark as not found when storage finds the value", async () => {
+      const { state, node, header } = setup();
+      let storageDone: any;
+
+      const storage = createMockStorage({
+        load: (id, callback, done) => {
+          storageDone = done;
+        },
+      });
+      node.setStorage(storage);
+
+      state.loadFromStorage();
+
+      // Provide header first
+      state.provideHeader(header);
+      const previousState = state.loadingState;
+      state.markFoundInPeer("storage", previousState);
+
+      // Call done with true
+      storageDone(true);
+
+      // State should be available, not unavailable
+      expect(state.getLoadingStateForPeer("storage")).not.toBe("unavailable");
+    });
+
+    test("should handle multiple concurrent loadFromStorage calls", async () => {
+      const { state, node, id } = setup();
+      const loadSpy = vi.fn();
+      const storage = createMockStorage({ load: loadSpy });
+      node.setStorage(storage);
+
+      const done1 = vi.fn();
+      const done2 = vi.fn();
+      const done3 = vi.fn();
+
+      // All three calls should work together
+      state.loadFromStorage(done1);
+      state.loadFromStorage(done2);
+      state.loadFromStorage(done3);
+
+      // Storage.load should only be called once (first call)
+      expect(loadSpy).toHaveBeenCalledTimes(1);
+
+      // The other calls should be waiting (pending state)
+      expect(done1).not.toHaveBeenCalled();
+      expect(done2).not.toHaveBeenCalled();
+      expect(done3).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("edge cases and integration", () => {
+    test("should handle transition from unknown to pending to available", async () => {
+      const { state, node, header } = setup();
+      let storageCallback: any;
+      let storageDone: any;
+
+      const storage = createMockStorage({
+        load: (id, callback, done) => {
+          storageCallback = callback;
+          storageDone = done;
+        },
+      });
+      node.setStorage(storage);
+
+      const doneSpy = vi.fn();
+
+      // Start as unknown
+      expect(state.getLoadingStateForPeer("storage")).toBe("unknown");
+
+      // Load from storage
+      state.loadFromStorage(doneSpy);
+
+      // Should now be pending
+      expect(state.getLoadingStateForPeer("storage")).toBe("pending");
+
+      // Simulate storage providing the header
+      state.provideHeader(header);
+      const previousState = state.loadingState;
+      state.markFoundInPeer("storage", previousState);
+
+      // Call done
+      storageDone(true);
+
+      // Should be available
+      expect(state.getLoadingStateForPeer("storage")).toBe("available");
+      expect(doneSpy).toHaveBeenCalledWith(true);
+    });
+
+    test("should properly clean up subscriptions when state becomes available through isAvailable()", async () => {
+      const { state, node, header } = setup();
+      const storage = createMockStorage({
+        load: vi.fn(),
+      });
+      node.setStorage(storage);
+
+      // Start initial load (will mark as pending)
+      state.loadFromStorage();
+
+      // Now try to load again with a done callback while pending
+      const doneSpy = vi.fn();
+      state.loadFromStorage(doneSpy);
+
+      // Make the whole state available (not just from storage peer)
+      state.provideHeader(header);
+      const previousState = state.loadingState;
+      state.markFoundInPeer("some_other_peer", previousState);
+
+      // Wait for subscription to process
+      await new Promise((resolve) => setImmediate(resolve));
+
+      // Should have called done(true) because isAvailable() is true
+      expect(doneSpy).toHaveBeenCalledTimes(1);
+      expect(doneSpy).toHaveBeenCalledWith(true);
+    });
+
+    test("should handle rapid state changes", async () => {
+      const { state, node, header } = setup();
+      const storage = createMockStorage({
+        load: vi.fn(),
+      });
+      node.setStorage(storage);
+
+      const doneSpy = vi.fn();
+
+      // Start loading
+      state.loadFromStorage(doneSpy);
+
+      // Rapid state changes
+      state.markPending("storage");
+      state.markNotFoundInPeer("storage");
+
+      const previousState = state.loadingState;
+      state.provideHeader(header);
+      state.markFoundInPeer("storage", previousState);
+
+      // Should have the final state
+      expect(state.getLoadingStateForPeer("storage")).toBe("available");
+    });
+  });
+});

package/src/tests/{coValueCoreLoadingState.test.ts → coValueCore.loadingState.test.ts}

@@ -1,16 +1,12 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { PeerState } from "../PeerState";
-import { CoValueCore, idforHeader } from "../coValueCore/coValueCore";
-import { CoValueHeader, VerifiedState } from "../coValueCore/verifiedState";
-import { RawCoID } from "../ids";
-import { LocalNode } from "../localNode";
 import { Peer } from "../sync";
 import {
   createTestMetricReader,
   createTestNode,
+  createUnloadedCoValue,
   tearDownTestMetricReader,
 } from "./testUtils";
-import { WasmCrypto } from "../crypto/WasmCrypto";
 
 let metricReader: ReturnType<typeof createTestMetricReader>;
 
@@ -25,18 +21,9 @@ afterEach(() => {
 function setup() {
   const node = createTestNode();
 
-  const header = {
-    type: "comap",
-    ruleset: { type: "ownedByGroup", group: "co_ztest123" },
-    meta: null,
-    ...node.crypto.createdNowUnique(),
-  } as CoValueHeader;
+  const { coValue, id, header } = createUnloadedCoValue(node);
 
-  const id = idforHeader(header, node.crypto);
-
-  const state = CoValueCore.fromID(id, node);
-
-  return { node, state, id, header };
+  return { node, state: coValue, id, header };
 }
 
 describe("CoValueCore loading state", () => {

package/src/tests/coValueCore.test.ts

@@ -451,9 +451,7 @@ describe("markErrored and isErroredInPeer", () => {
     expect(coValue.isErroredInPeer(peerId)).toBe(true);
 
     // Verify the peer state contains the error
-    const peerState = coValue.getStateForPeer(peerId);
-    expect(peerState).toBeDefined();
-    expect(peerState?.type).toBe("errored");
+    expect(coValue.getLoadingStateForPeer(peerId)).toBe("errored");
   });
 
   test("markErrored should update loading state and notify listeners", () => {
@@ -632,8 +630,7 @@ describe("markErrored and isErroredInPeer", () => {
     // Verify the peer is now errored
     expect(coValue.isErroredInPeer(peerId)).toBe(true);
 
-    const peerState = coValue.getStateForPeer(peerId);
-    expect(peerState?.type).toBe("errored");
+    expect(coValue.getLoadingStateForPeer(peerId)).toBe("errored");
   });
 
   test("markErrored should work with different error types", () => {

package/src/tests/sync.mesh.test.ts

@@ -276,44 +276,17 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
       expect(coValue.get("fromClient")).toEqual("updated");
     });
 
-    expect(
-      SyncMessagesLog.getMessages({
-        Group: group.core,
-        Map: map.core,
-      }),
-    ).toMatchInlineSnapshot(`
-      [
-        "client -> edge-italy | LOAD Map sessions: empty",
-        "edge-italy -> storage | CONTENT Group header: true new: After: 0 New: 5",
-        "edge-italy -> core | CONTENT Group header: true new: After: 0 New: 5",
-        "edge-italy -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "edge-italy -> core | CONTENT Map header: true new: After: 0 New: 1",
-        "edge-italy -> client | CONTENT Group header: true new: After: 0 New: 5",
-        "edge-italy -> client | CONTENT Map header: true new: After: 0 New: 1",
-        "core -> edge-italy | KNOWN Group sessions: header/5",
-        "core -> storage | CONTENT Group header: true new: After: 0 New: 5",
-        "core -> edge-italy | KNOWN Map sessions: header/1",
-        "core -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "client -> edge-italy | KNOWN Group sessions: header/5",
-        "client -> edge-italy | KNOWN Map sessions: header/1",
-        "client -> edge-italy | CONTENT Map header: false new: After: 0 New: 1",
-        "core -> storage | CONTENT Map header: false new: After: 0 New: 1",
-        "core -> edge-italy | CONTENT Map header: false new: After: 0 New: 1",
-        "edge-italy -> client | KNOWN CORRECTION Map sessions: empty",
-        "edge-italy -> core | KNOWN CORRECTION Map sessions: empty",
-        "client -> edge-italy | CONTENT Map header: true new: After: 0 New: 1 | After: 0 New: 1",
-        "core -> edge-italy | CONTENT Map header: true new: After: 0 New: 1 | After: 0 New: 1",
-        "edge-italy -> client | KNOWN Map sessions: header/2",
-        "edge-italy -> storage | CONTENT Map header: true new: After: 0 New: 1 | After: 0 New: 1",
-        "edge-italy -> core | CONTENT Map header: false new: After: 0 New: 1",
-        "edge-italy -> core | KNOWN Map sessions: header/3",
-        "edge-italy -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "edge-italy -> client | CONTENT Map header: false new: After: 0 New: 1",
-        "core -> edge-italy | KNOWN Map sessions: header/3",
-        "core -> storage | CONTENT Map header: false new: After: 0 New: 1",
-        "client -> edge-italy | KNOWN Map sessions: header/3",
-      ]
-    `);
+    const syncLog = SyncMessagesLog.getMessages({
+      Group: group.core,
+      Map: map.core,
+    });
+
+    expect(syncLog).toContain(
+      "edge-italy -> client | KNOWN CORRECTION Map sessions: empty",
+    );
+    expect(syncLog).toContain(
+      "edge-italy -> core | KNOWN CORRECTION Map sessions: empty",
+    );
   });
 
   test("sync of changes of a coValue with bad signatures should be blocked", async () => {

package/src/tests/testUtils.ts

@@ -10,6 +10,7 @@ import { ControlledAccount, ControlledAgent } from "../coValues/account.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import {
   type AgentSecret,
+  AnyRawCoValue,
   type CoID,
   type CoValueCore,
   type RawAccount,
@@ -24,6 +25,8 @@ import { expectGroup } from "../typeUtils/expectGroup.js";
 import { toSimplifiedMessages } from "./messagesTestUtils.js";
 import { createAsyncStorage, createSyncStorage } from "./testStorage.js";
 import { PureJSCrypto } from "../crypto/PureJSCrypto.js";
+import { CoValueHeader } from "../coValueCore/verifiedState.js";
+import { idforHeader } from "../coValueCore/coValueCore.js";
 
 let Crypto = await WasmCrypto.create();
 
@@ -722,3 +725,21 @@ export function createAccountInNode(node: LocalNode) {
     accountOnTempNode.core.node.agentSecret,
   );
 }
+
+export function createUnloadedCoValue(
+  node: LocalNode,
+  type: AnyRawCoValue["type"] = "comap",
+) {
+  const header = {
+    type,
+    ruleset: { type: "ownedByGroup", group: node.getCurrentAccountOrAgentID() },
+    meta: null,
+    ...node.crypto.createdNowUnique(),
+  } as CoValueHeader;
+
+  const id = idforHeader(header, node.crypto);
+
+  const state = node.getCoValue(id);
+
+  return { coValue: state, id, header };
+}

package/dist/coValueCore/decodeTransactionChangesAndMeta.d.ts

@@ -1,3 +0,0 @@
-import { AvailableCoValueCore, VerifiedTransaction } from "./coValueCore.js";
-export declare function decodeTransactionChangesAndMeta(coValue: AvailableCoValueCore, transaction: VerifiedTransaction, ignorePrivateTransactions: boolean): void;
-//# sourceMappingURL=decodeTransactionChangesAndMeta.d.ts.map