cojson 0.19.19 → 0.19.21

package/src/tests/StorageApiAsync.test.ts

@@ -823,4 +823,140 @@ describe("StorageApiAsync", () => {
       expect(() => storage.close()).not.toThrow();
     });
   });
+
+  describe("loadKnownState", () => {
+    test("should return cached knownState if available", async () => {
+      const { fixturesNode, dbPath } = await createFixturesNode();
+      const { storage } = await createTestNode(dbPath);
+
+      // Create a group to have data in the database
+      const group = fixturesNode.createGroup();
+      group.addMember("everyone", "reader");
+      await group.core.waitForSync();
+
+      // First call should hit the database and cache the result
+      const result1 = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        },
+      );
+
+      expect(result1).toBeDefined();
+      expect(result1?.id).toBe(group.id);
+      expect(result1?.header).toBe(true);
+
+      // Second call should return from cache
+      const result2 = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        },
+      );
+
+      expect(result2).toEqual(result1);
+    });
+
+    test("should return undefined for non-existent CoValue", async () => {
+      const { storage } = await createTestNode();
+
+      const result = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState("co_nonexistent" as any, resolve);
+        },
+      );
+
+      expect(result).toBeUndefined();
+    });
+
+    test("should deduplicate concurrent requests for the same ID", async () => {
+      const { fixturesNode, dbPath } = await createFixturesNode();
+      const { storage } = await createTestNode(dbPath);
+
+      // Create a group to have data in the database
+      const group = fixturesNode.createGroup();
+      group.addMember("everyone", "reader");
+      await group.core.waitForSync();
+
+      // Clear the cache to force database access
+      storage.knownStates.knownStates.clear();
+
+      // Spy on the database client to track how many times it's called
+      const dbClientSpy = vi.spyOn(
+        (storage as any).dbClient,
+        "getCoValueKnownState",
+      );
+
+      // Make multiple concurrent requests for the same ID
+      const promises = [
+        new Promise<CoValueKnownState | undefined>((resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        }),
+        new Promise<CoValueKnownState | undefined>((resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        }),
+        new Promise<CoValueKnownState | undefined>((resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        }),
+      ];
+
+      const results = await Promise.all(promises);
+
+      // All results should be the same
+      expect(results[0]).toEqual(results[1]);
+      expect(results[1]).toEqual(results[2]);
+      expect(results[0]?.id).toBe(group.id);
+
+      // Database should only be called once due to deduplication
+      expect(dbClientSpy).toHaveBeenCalledTimes(1);
+    });
+
+    test("should use cache and not query database when cache is populated", async () => {
+      const { fixturesNode, dbPath } = await createFixturesNode();
+      const { storage } = await createTestNode(dbPath);
+
+      // Create a group to have data in the database
+      const group = fixturesNode.createGroup();
+      group.addMember("everyone", "reader");
+      await group.core.waitForSync();
+
+      // Spy on the database client to track calls
+      const dbClientSpy = vi.spyOn(
+        (storage as any).dbClient,
+        "getCoValueKnownState",
+      );
+
+      // First call - should hit the database
+      const result1 = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        },
+      );
+
+      expect(result1).toBeDefined();
+      expect(dbClientSpy).toHaveBeenCalledTimes(1);
+
+      // Clear the spy to reset call count
+      dbClientSpy.mockClear();
+
+      // Second call - should use cache, not database
+      const result2 = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        },
+      );
+
+      expect(result2).toEqual(result1);
+      // Database should NOT be called since cache was hit
+      expect(dbClientSpy).toHaveBeenCalledTimes(0);
+
+      // Third call - also from cache
+      const result3 = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        },
+      );
+
+      expect(result3).toEqual(result1);
+      expect(dbClientSpy).toHaveBeenCalledTimes(0);
+    });
+  });
 });

package/src/tests/StorageApiSync.test.ts

@@ -619,4 +619,136 @@ describe("StorageApiSync", () => {
       expect(() => storage.close()).not.toThrow();
     });
   });
+
+  describe("loadKnownState", () => {
+    test("should return correct knownState structure for existing CoValue", async () => {
+      const { fixturesNode, dbPath } = await createFixturesNode();
+      const { storage } = await createTestNode(dbPath);
+
+      // Create a group to have data in the database
+      const group = fixturesNode.createGroup();
+      group.addMember("everyone", "reader");
+      await group.core.waitForSync();
+
+      const result = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        },
+      );
+
+      expect(result).toBeDefined();
+      expect(result?.id).toBe(group.id);
+      expect(result?.header).toBe(true);
+      expect(result?.sessions).toEqual(group.core.knownState().sessions);
+    });
+
+    test("should return undefined for non-existent CoValue", async () => {
+      const { storage } = await createTestNode();
+
+      const result = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState("co_nonexistent" as any, resolve);
+        },
+      );
+
+      expect(result).toBeUndefined();
+    });
+
+    test("should handle CoValue with no sessions (header only)", async () => {
+      const { fixturesNode, dbPath } = await createFixturesNode();
+      const { storage } = await createTestNode(dbPath);
+
+      // Create a CoValue with just a header (no transactions yet)
+      const coValue = fixturesNode.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...crypto.createdNowUnique(),
+      });
+      await coValue.waitForSync();
+
+      const result = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState(coValue.id, resolve);
+        },
+      );
+
+      expect(result).toBeDefined();
+      expect(result?.id).toBe(coValue.id);
+      expect(result?.header).toBe(true);
+      // The sessions should have one entry with lastIdx = 0 (just header)
+      expect(Object.keys(result?.sessions || {}).length).toBe(0);
+    });
+
+    test("should handle CoValue with multiple sessions", async () => {
+      const { fixturesNode, dbPath } = await createFixturesNode();
+      const { fixturesNode: fixturesNode2 } = await createFixturesNode(dbPath);
+      const { storage } = await createTestNode(dbPath);
+
+      // Create a CoValue and have two nodes make transactions
+      const coValue = fixturesNode.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...crypto.createdNowUnique(),
+      });
+
+      coValue.makeTransaction([{ key1: "value1" }], "trusting");
+      await coValue.waitForSync();
+
+      const coValueOnNode2 = await loadCoValueOrFail(
+        fixturesNode2,
+        coValue.id as CoID<RawCoMap>,
+      );
+
+      coValueOnNode2.set("key2", "value2", "trusting");
+      await coValueOnNode2.core.waitForSync();
+
+      const result = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState(coValue.id, resolve);
+        },
+      );
+
+      expect(result).toBeDefined();
+      expect(result?.id).toBe(coValue.id);
+      expect(result?.header).toBe(true);
+      // Should have two sessions
+      expect(Object.keys(result?.sessions || {}).length).toBe(2);
+      // Verify sessions match the expected state
+      expect(result?.sessions).toEqual(
+        coValueOnNode2.core.knownState().sessions,
+      );
+    });
+
+    test("should use cache when knownState is cached", async () => {
+      const { fixturesNode, dbPath } = await createFixturesNode();
+      const { storage } = await createTestNode(dbPath);
+
+      // Create a group to have data in the database
+      const group = fixturesNode.createGroup();
+      group.addMember("everyone", "reader");
+      await group.core.waitForSync();
+
+      // First call should hit the database and cache the result
+      const result1 = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        },
+      );
+
+      expect(result1).toBeDefined();
+      expect(result1?.id).toBe(group.id);
+      expect(result1?.header).toBe(true);
+
+      // Second call should return from cache
+      const result2 = await new Promise<CoValueKnownState | undefined>(
+        (resolve) => {
+          storage.loadKnownState(group.id, resolve);
+        },
+      );
+
+      expect(result2).toEqual(result1);
+    });
+  });
 });

package/src/tests/StorageStreamingQueue.test.ts

@@ -0,0 +1,276 @@
+import { describe, expect, test, vi } from "vitest";
+import { CO_VALUE_PRIORITY } from "../priority.js";
+import { StorageStreamingQueue } from "../queue/StorageStreamingQueue.js";
+
+describe("StorageStreamingQueue", () => {
+  describe("constructor", () => {
+    test("should initialize with empty queues", () => {
+      const queue = new StorageStreamingQueue();
+      expect(queue.isEmpty()).toBe(true);
+    });
+  });
+
+  describe("push", () => {
+    test("should add MEDIUM priority entry to queue", () => {
+      const queue = new StorageStreamingQueue();
+
+      queue.push(() => {}, CO_VALUE_PRIORITY.MEDIUM);
+
+      expect(queue.isEmpty()).toBe(false);
+    });
+
+    test("should add LOW priority entry to queue", () => {
+      const queue = new StorageStreamingQueue();
+
+      queue.push(() => {}, CO_VALUE_PRIORITY.LOW);
+
+      expect(queue.isEmpty()).toBe(false);
+    });
+
+    test("should add HIGH priority entry to queue", () => {
+      const queue = new StorageStreamingQueue();
+
+      queue.push(() => {}, CO_VALUE_PRIORITY.HIGH);
+
+      expect(queue.isEmpty()).toBe(false);
+    });
+
+    test("should accept multiple entries", () => {
+      const queue = new StorageStreamingQueue();
+      const entry1 = () => {};
+      const entry2 = () => {};
+
+      queue.push(entry1, CO_VALUE_PRIORITY.MEDIUM);
+      queue.push(entry2, CO_VALUE_PRIORITY.MEDIUM);
+
+      expect(queue.pull()).toBe(entry1);
+      expect(queue.pull()).toBe(entry2);
+    });
+  });
+
+  describe("pull", () => {
+    test("should return undefined for empty queue", () => {
+      const queue = new StorageStreamingQueue();
+      expect(queue.pull()).toBeUndefined();
+    });
+
+    test("should return and remove entry from queue", () => {
+      const queue = new StorageStreamingQueue();
+      const entry = () => {};
+
+      queue.push(entry, CO_VALUE_PRIORITY.MEDIUM);
+      const pulled = queue.pull();
+
+      expect(pulled).toBe(entry);
+      expect(queue.isEmpty()).toBe(true);
+    });
+
+    test("should pull HIGH priority before MEDIUM and LOW", () => {
+      const queue = new StorageStreamingQueue();
+      const lowEntry = () => {};
+      const mediumEntry = () => {};
+      const highEntry = () => {};
+
+      // Push in reverse order
+      queue.push(lowEntry, CO_VALUE_PRIORITY.LOW);
+      queue.push(mediumEntry, CO_VALUE_PRIORITY.MEDIUM);
+      queue.push(highEntry, CO_VALUE_PRIORITY.HIGH);
+
+      // Should pull HIGH first, then MEDIUM, then LOW
+      expect(queue.pull()).toBe(highEntry);
+      expect(queue.pull()).toBe(mediumEntry);
+      expect(queue.pull()).toBe(lowEntry);
+    });
+
+    test("should pull MEDIUM priority before LOW priority", () => {
+      const queue = new StorageStreamingQueue();
+      const lowEntry = () => {};
+      const mediumEntry = () => {};
+
+      // Push LOW first, then MEDIUM
+      queue.push(lowEntry, CO_VALUE_PRIORITY.LOW);
+      queue.push(mediumEntry, CO_VALUE_PRIORITY.MEDIUM);
+
+      // Should pull MEDIUM first
+      expect(queue.pull()).toBe(mediumEntry);
+      expect(queue.pull()).toBe(lowEntry);
+    });
+
+    test("should pull entries in FIFO order within same priority", () => {
+      const queue = new StorageStreamingQueue();
+      const entry1 = () => {};
+      const entry2 = () => {};
+      const entry3 = () => {};
+
+      queue.push(entry1, CO_VALUE_PRIORITY.MEDIUM);
+      queue.push(entry2, CO_VALUE_PRIORITY.MEDIUM);
+      queue.push(entry3, CO_VALUE_PRIORITY.MEDIUM);
+
+      expect(queue.pull()).toBe(entry1);
+      expect(queue.pull()).toBe(entry2);
+      expect(queue.pull()).toBe(entry3);
+    });
+
+    test("should handle interleaved priorities correctly", () => {
+      const queue = new StorageStreamingQueue();
+      const low1 = () => {};
+      const medium1 = () => {};
+      const high1 = () => {};
+      const low2 = () => {};
+      const medium2 = () => {};
+      const high2 = () => {};
+
+      queue.push(low1, CO_VALUE_PRIORITY.LOW);
+      queue.push(medium1, CO_VALUE_PRIORITY.MEDIUM);
+      queue.push(high1, CO_VALUE_PRIORITY.HIGH);
+      queue.push(low2, CO_VALUE_PRIORITY.LOW);
+      queue.push(medium2, CO_VALUE_PRIORITY.MEDIUM);
+      queue.push(high2, CO_VALUE_PRIORITY.HIGH);
+
+      // All HIGH should come first, in order
+      expect(queue.pull()).toBe(high1);
+      expect(queue.pull()).toBe(high2);
+      // Then all MEDIUM, in order
+      expect(queue.pull()).toBe(medium1);
+      expect(queue.pull()).toBe(medium2);
+      // Then all LOW, in order
+      expect(queue.pull()).toBe(low1);
+      expect(queue.pull()).toBe(low2);
+    });
+  });
+
+  describe("isEmpty", () => {
+    test("should return true for empty queue", () => {
+      const queue = new StorageStreamingQueue();
+      expect(queue.isEmpty()).toBe(true);
+    });
+
+    test("should return false when MEDIUM queue has entries", () => {
+      const queue = new StorageStreamingQueue();
+      queue.push(() => {}, CO_VALUE_PRIORITY.MEDIUM);
+      expect(queue.isEmpty()).toBe(false);
+    });
+
+    test("should return false when LOW queue has entries", () => {
+      const queue = new StorageStreamingQueue();
+      queue.push(() => {}, CO_VALUE_PRIORITY.LOW);
+      expect(queue.isEmpty()).toBe(false);
+    });
+
+    test("should return false when HIGH queue has entries", () => {
+      const queue = new StorageStreamingQueue();
+      queue.push(() => {}, CO_VALUE_PRIORITY.HIGH);
+      expect(queue.isEmpty()).toBe(false);
+    });
+
+    test("should return true after all entries are pulled", () => {
+      const queue = new StorageStreamingQueue();
+      queue.push(() => {}, CO_VALUE_PRIORITY.MEDIUM);
+      queue.push(() => {}, CO_VALUE_PRIORITY.LOW);
+
+      queue.pull();
+      queue.pull();
+
+      expect(queue.isEmpty()).toBe(true);
+    });
+  });
+
+  describe("callback invocation", () => {
+    test("should not invoke callback when pushed", () => {
+      const queue = new StorageStreamingQueue();
+      const callback = vi.fn();
+
+      queue.push(callback, CO_VALUE_PRIORITY.MEDIUM);
+
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    test("should not invoke callback when pulled", () => {
+      const queue = new StorageStreamingQueue();
+      const callback = vi.fn();
+
+      queue.push(callback, CO_VALUE_PRIORITY.MEDIUM);
+      queue.pull();
+
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    test("should allow caller to invoke callback after pull", () => {
+      const queue = new StorageStreamingQueue();
+      const callback = vi.fn();
+
+      queue.push(callback, CO_VALUE_PRIORITY.MEDIUM);
+      const pulled = queue.pull();
+
+      expect(callback).not.toHaveBeenCalled();
+
+      pulled?.();
+
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("setListener and emit", () => {
+    test("should call listener when emit is called", () => {
+      const queue = new StorageStreamingQueue();
+      const listener = vi.fn();
+
+      queue.setListener(listener);
+      queue.emit();
+
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    test("should not throw when emit is called without listener", () => {
+      const queue = new StorageStreamingQueue();
+
+      expect(() => queue.emit()).not.toThrow();
+    });
+
+    test("should call listener multiple times on multiple emits", () => {
+      const queue = new StorageStreamingQueue();
+      const listener = vi.fn();
+
+      queue.setListener(listener);
+      queue.emit();
+      queue.emit();
+      queue.emit();
+
+      expect(listener).toHaveBeenCalledTimes(3);
+    });
+
+    test("should use latest listener when setListener is called multiple times", () => {
+      const queue = new StorageStreamingQueue();
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+
+      queue.setListener(listener1);
+      queue.setListener(listener2);
+      queue.emit();
+
+      expect(listener1).not.toHaveBeenCalled();
+      expect(listener2).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("edge cases", () => {
+    test("should handle alternating push and pull operations", () => {
+      const queue = new StorageStreamingQueue();
+
+      const entry1 = () => {};
+      const entry2 = () => {};
+      const entry3 = () => {};
+
+      queue.push(entry1, CO_VALUE_PRIORITY.MEDIUM);
+      expect(queue.pull()).toBe(entry1);
+
+      queue.push(entry2, CO_VALUE_PRIORITY.LOW);
+      expect(queue.pull()).toBe(entry2);
+
+      expect(queue.isEmpty()).toBe(true);
+
+      queue.push(entry3, CO_VALUE_PRIORITY.MEDIUM);
+      expect(queue.pull()).toBe(entry3);
+    });
+  });
+});