cojson-storage-indexeddb 0.8.32 → 0.8.35

package/src/tests/getDependedOnCoValues.test.ts

@@ -0,0 +1,179 @@
+import { CojsonInternalTypes, SessionID, Stringified } from "cojson";
+import { describe, expect, it, vi } from "vitest";
+import { getDependedOnCoValues } from "../syncUtils";
+
+function getMockedSessionID(accountId?: `co_z${string}`) {
+  return `${accountId ?? getMockedCoValueId()}_session_z${Math.random().toString(36).substring(2, 15)}`;
+}
+
+function getMockedCoValueId() {
+  return `co_z${Math.random().toString(36).substring(2, 15)}` as const;
+}
+
+function generateNewContentMessage(
+  privacy: "trusting" | "private",
+  changes: any[],
+  accountId?: `co_z${string}`,
+) {
+  return {
+    action: "content",
+    id: getMockedCoValueId(),
+    new: {
+      [getMockedSessionID(accountId)]: {
+        after: 0,
+        lastSignature: "signature_z123",
+        newTransactions: [
+          {
+            privacy,
+            madeAt: 0,
+            changes: JSON.stringify(changes) as any,
+          },
+        ],
+      },
+    },
+    priority: 0,
+  } as CojsonInternalTypes.NewContentMessage;
+}
+
+describe("getDependedOnCoValues", () => {
+  it("should return dependencies for group ruleset", () => {
+    const coValueRow = {
+      id: "co_test",
+      header: {
+        ruleset: {
+          type: "group",
+        },
+      },
+    } as any;
+
+    const result = getDependedOnCoValues({
+      coValueRow,
+      newContentMessages: [
+        generateNewContentMessage("trusting", [
+          { op: "set", key: "co_zabc123", value: "test" },
+          { op: "set", key: "parent_co_zdef456", value: "test" },
+          { op: "set", key: "normal_key", value: "test" },
+        ]),
+      ],
+    });
+
+    expect(result).toEqual(["co_zabc123", "co_zdef456"]);
+  });
+
+  it("should not throw on malformed JSON", () => {
+    const coValueRow = {
+      id: "co_test",
+      header: {
+        ruleset: {
+          type: "group",
+        },
+      },
+    } as any;
+
+    const message = generateNewContentMessage("trusting", [
+      { op: "set", key: "co_zabc123", value: "test" },
+    ]);
+
+    message.new["invalid_session" as SessionID] = {
+      after: 0,
+      lastSignature: "signature_z123",
+      newTransactions: [
+        {
+          privacy: "trusting",
+          madeAt: 0,
+          changes: "}{-:)" as Stringified<CojsonInternalTypes.JsonObject[]>,
+        },
+      ],
+    };
+
+    const result = getDependedOnCoValues({
+      coValueRow,
+      newContentMessages: [message],
+    });
+
+    expect(result).toEqual(["co_zabc123"]);
+  });
+
+  it("should return dependencies for ownedByGroup ruleset", () => {
+    const groupId = getMockedCoValueId();
+    const coValueRow = {
+      id: "co_owner",
+      header: {
+        ruleset: {
+          type: "ownedByGroup",
+          group: groupId,
+        },
+      },
+    } as any;
+
+    const accountId = getMockedCoValueId();
+    const message = generateNewContentMessage(
+      "trusting",
+      [
+        { op: "set", key: "co_zabc123", value: "test" },
+        { op: "set", key: "parent_co_zdef456", value: "test" },
+        { op: "set", key: "normal_key", value: "test" },
+      ],
+      accountId,
+    );
+
+    message.new["invalid_session" as SessionID] = {
+      after: 0,
+      lastSignature: "signature_z123",
+      newTransactions: [],
+    };
+
+    const result = getDependedOnCoValues({
+      coValueRow,
+      newContentMessages: [message],
+    });
+
+    expect(result).toEqual([groupId, accountId]);
+  });
+
+  it("should return empty array for other ruleset types", () => {
+    const coValueRow = {
+      id: "co_test",
+      header: {
+        ruleset: {
+          type: "other",
+        },
+      },
+    } as any;
+
+    const result = getDependedOnCoValues({
+      coValueRow,
+      newContentMessages: [
+        generateNewContentMessage("trusting", [
+          { op: "set", key: "co_zabc123", value: "test" },
+          { op: "set", key: "parent_co_zdef456", value: "test" },
+          { op: "set", key: "normal_key", value: "test" },
+        ]),
+      ],
+    });
+
+    expect(result).toEqual([]);
+  });
+
+  it("should ignore non-trusting transactions in group ruleset", () => {
+    const coValueRow = {
+      id: "co_test",
+      header: {
+        ruleset: {
+          type: "group",
+        },
+      },
+    } as any;
+
+    const result = getDependedOnCoValues({
+      coValueRow,
+      newContentMessages: [
+        generateNewContentMessage("private", [
+          { op: "set", key: "co_zabc123", value: "test" },
+        ]),
+      ],
+    });
+
+    expect(result).toEqual([]);
+  });
+});

package/src/tests/{index.test.ts → idbNode.test.ts}

@@ -6,7 +6,7 @@ import { IDBStorage } from "../index.js";
 
 const Crypto = await WasmCrypto.create();
 
-test.skip("Should be able to initialize and load from empty DB", async () => {
+test("Should be able to initialize and load from empty DB", async () => {
   const agentSecret = Crypto.newRandomAgentSecret();
 
   const node = new LocalNode(
@@ -23,7 +23,7 @@ test.skip("Should be able to initialize and load from empty DB", async () => {
 
   await new Promise((resolve) => setTimeout(resolve, 200));
 
-  expect(node.syncManager.peers["storage"]).toBeDefined();
+  expect(node.syncManager.peers["indexedDB"]).toBeDefined();
 });
 
 test("Should be able to sync data to database and then load that from a new node", async () => {

package/src/tests/syncManager.test.ts

@@ -0,0 +1,337 @@
+import {
+  Mocked,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  test,
+  vi,
+} from "vitest";
+
+import {
+  CojsonInternalTypes,
+  OutgoingSyncQueue,
+  SessionID,
+  SyncMessage,
+} from "cojson";
+import { IDBClient } from "../idbClient";
+import { SyncManager } from "../syncManager";
+import { getDependedOnCoValues } from "../syncUtils";
+import { fixtures } from "./fixtureMessages";
+import RawCoID = CojsonInternalTypes.RawCoID;
+import NewContentMessage = CojsonInternalTypes.NewContentMessage;
+
+vi.mock("../syncUtils");
+
+const coValueIdToLoad = "co_zKwG8NyfZ8GXqcjDHY4NS3SbU2m";
+const createEmptyLoadMsg = (id: string) =>
+  ({
+    action: "load",
+    id,
+    header: false,
+    sessions: {},
+  }) as SyncMessage;
+
+const sessionsData = fixtures[coValueIdToLoad].sessionRecords;
+const coValueHeader = fixtures[coValueIdToLoad].getContent({ after: 0 }).header;
+const incomingContentMessage = fixtures[coValueIdToLoad].getContent({
+  after: 0,
+}) as SyncMessage;
+
+describe("IDB sync manager", () => {
+  let syncManager: SyncManager;
+  let queue: OutgoingSyncQueue = {} as unknown as OutgoingSyncQueue;
+
+  const IDBClient = vi.fn();
+  IDBClient.prototype.getCoValue = vi.fn();
+  IDBClient.prototype.getCoValueSessions = vi.fn();
+  IDBClient.prototype.addSessionUpdate = vi.fn();
+  IDBClient.prototype.addTransaction = vi.fn();
+
+  beforeEach(async () => {
+    const idbClient = new IDBClient() as unknown as Mocked<IDBClient>;
+    syncManager = new SyncManager(idbClient, queue);
+    syncManager.sendStateMessage = vi.fn();
+
+    // No dependencies found
+    vi.mocked(getDependedOnCoValues).mockReturnValue([]);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("Incoming known messages are not processed", async () => {
+    await syncManager.handleSyncMessage({ action: "known" } as SyncMessage);
+    expect(syncManager.sendStateMessage).not.toBeCalled();
+  });
+
+  describe("Handle load incoming message", () => {
+    test("sends empty known message for unknown coValue", async () => {
+      const loadMsg = createEmptyLoadMsg(coValueIdToLoad);
+
+      IDBClient.prototype.getCoValue.mockResolvedValueOnce(undefined);
+
+      await syncManager.handleSyncMessage(loadMsg);
+
+      expect(syncManager.sendStateMessage).toBeCalledWith({
+        action: "known",
+        header: false,
+        id: coValueIdToLoad,
+        sessions: {},
+      });
+    });
+
+    test("Sends known and content message for known coValue with no sessions", async () => {
+      const loadMsg = createEmptyLoadMsg(coValueIdToLoad);
+
+      IDBClient.prototype.getCoValue.mockResolvedValueOnce({
+        id: coValueIdToLoad,
+        header: coValueHeader,
+        rowID: 3,
+      });
+      IDBClient.prototype.getCoValueSessions.mockResolvedValueOnce([]);
+
+      await syncManager.handleSyncMessage(loadMsg);
+
+      expect(syncManager.sendStateMessage).toBeCalledTimes(2);
+      expect(syncManager.sendStateMessage).toBeCalledWith({
+        action: "known",
+        header: true,
+        id: coValueIdToLoad,
+        sessions: {},
+      });
+      expect(syncManager.sendStateMessage).toBeCalledWith({
+        action: "content",
+        header: expect.objectContaining({
+          type: expect.any(String),
+          ruleset: expect.any(Object),
+        }),
+        id: coValueIdToLoad,
+        new: {},
+        priority: 0,
+      });
+    });
+
+    test("Sends both known and content messages when we have new sessions info for the requested coValue ", async () => {
+      const loadMsg = createEmptyLoadMsg(coValueIdToLoad);
+
+      IDBClient.prototype.getCoValue.mockResolvedValueOnce({
+        id: coValueIdToLoad,
+        header: coValueHeader,
+        rowID: 3,
+      });
+      IDBClient.prototype.getCoValueSessions.mockResolvedValueOnce(
+        sessionsData,
+      );
+
+      const newTxData = {
+        newTransactions: [
+          {
+            privacy: "trusting",
+            madeAt: 1732368535089,
+            changes: "",
+          } as CojsonInternalTypes.Transaction,
+        ],
+        after: 0,
+        lastSignature: "signature_z111",
+      } satisfies CojsonInternalTypes.SessionNewContent;
+
+      // mock content data combined with session updates
+      syncManager.handleSessionUpdate = vi.fn(
+        async ({ sessionRow, newContentMessages }) => {
+          newContentMessages[0]!.new[sessionRow.sessionID] = newTxData;
+        },
+      );
+
+      await syncManager.handleSyncMessage(loadMsg);
+
+      expect(syncManager.sendStateMessage).toBeCalledTimes(2);
+
+      expect(syncManager.sendStateMessage).toHaveBeenNthCalledWith(1, {
+        action: "known",
+        header: true,
+        id: coValueIdToLoad,
+        sessions: sessionsData.reduce(
+          (acc, sessionRow) => ({
+            ...acc,
+            [sessionRow.sessionID]: sessionRow.lastIdx,
+          }),
+          {},
+        ),
+      });
+
+      expect(syncManager.sendStateMessage).toHaveBeenNthCalledWith(2, {
+        action: "content",
+        header: coValueHeader,
+        id: coValueIdToLoad,
+        new: sessionsData.reduce(
+          (acc, sessionRow) => ({
+            ...acc,
+            [sessionRow.sessionID]: {
+              after: expect.any(Number),
+              lastSignature: expect.any(String),
+              newTransactions: expect.any(Array),
+            },
+          }),
+          {},
+        ),
+        priority: 0,
+      });
+    });
+
+    test("Sends messages for unique coValue dependencies only, leaving out circular dependencies", async () => {
+      const loadMsg = createEmptyLoadMsg(coValueIdToLoad);
+      const dependency1 = "co_zMKhQJs5rAeGjta3JX2qEdBS6hS";
+      const dependency2 = "co_zP51HdyAVCuRY9ptq5iu8DhMyAb";
+      const dependency3 = "co_zGyBniuJmKkcirCKYrccWpjQEFY";
+      const dependenciesTreeWithLoop: Record<RawCoID, RawCoID[]> = {
+        [coValueIdToLoad]: [dependency1, dependency2],
+        [dependency1]: [],
+        [dependency2]: [coValueIdToLoad, dependency3],
+        [dependency3]: [dependency1],
+      };
+
+      IDBClient.prototype.getCoValue.mockImplementation(
+        (coValueId: RawCoID) => ({
+          id: coValueId,
+          header: coValueHeader,
+          rowID: 3,
+        }),
+      );
+
+      IDBClient.prototype.getCoValueSessions.mockResolvedValue([]);
+
+      // Fetch dependencies of the current dependency for the future recursion iterations
+      vi.mocked(getDependedOnCoValues).mockImplementation(
+        ({ coValueRow }) => dependenciesTreeWithLoop[coValueRow.id] || [],
+      );
+
+      await syncManager.handleSyncMessage(loadMsg);
+
+      // We send out pairs (known + content) messages only FOUR times - as many as the coValues number
+      // and less than amount of interconnected dependencies to loop through in dependenciesTreeWithLoop
+      expect(syncManager.sendStateMessage).toBeCalledTimes(4 * 2);
+
+      const knownExpected = {
+        action: "known",
+        header: true,
+        sessions: {},
+      };
+
+      const contentExpected = {
+        action: "content",
+        header: expect.any(Object),
+        new: {},
+        priority: 0,
+      };
+
+      expect(syncManager.sendStateMessage).toHaveBeenNthCalledWith(1, {
+        ...knownExpected,
+        id: dependency3,
+        asDependencyOf: coValueIdToLoad,
+      });
+      expect(syncManager.sendStateMessage).toHaveBeenNthCalledWith(2, {
+        ...contentExpected,
+        id: dependency3,
+      });
+      expect(syncManager.sendStateMessage).toHaveBeenNthCalledWith(3, {
+        ...knownExpected,
+        id: dependency2,
+        asDependencyOf: coValueIdToLoad,
+      });
+      expect(syncManager.sendStateMessage).toHaveBeenNthCalledWith(4, {
+        ...contentExpected,
+        id: dependency2,
+      });
+      expect(syncManager.sendStateMessage).toHaveBeenNthCalledWith(5, {
+        ...knownExpected,
+        id: dependency1,
+        asDependencyOf: coValueIdToLoad,
+      });
+      expect(syncManager.sendStateMessage).toHaveBeenNthCalledWith(6, {
+        ...contentExpected,
+        id: dependency1,
+      });
+      expect(syncManager.sendStateMessage).toHaveBeenNthCalledWith(7, {
+        ...knownExpected,
+        id: coValueIdToLoad,
+      });
+      expect(syncManager.sendStateMessage).toHaveBeenNthCalledWith(8, {
+        ...contentExpected,
+        id: coValueIdToLoad,
+      });
+    });
+  });
+
+  describe("Handle content incoming message", () => {
+    test("Sends correction message for unknown coValue", async () => {
+      IDBClient.prototype.getCoValue.mockResolvedValueOnce(undefined);
+
+      await syncManager.handleSyncMessage({
+        ...incomingContentMessage,
+        header: undefined,
+      } as SyncMessage);
+
+      expect(syncManager.sendStateMessage).toBeCalledWith({
+        action: "known",
+        header: false,
+        id: coValueIdToLoad,
+        isCorrection: true,
+        sessions: {},
+      });
+    });
+
+    test("Saves new transaction without sending message when IDB has fewer transactions", async () => {
+      IDBClient.prototype.getCoValue.mockResolvedValueOnce({
+        id: coValueIdToLoad,
+        header: coValueHeader,
+        rowID: 3,
+      });
+      IDBClient.prototype.getCoValueSessions.mockResolvedValueOnce([]);
+      const msg = {
+        ...incomingContentMessage,
+        header: undefined,
+      } as NewContentMessage;
+
+      await syncManager.handleSyncMessage(msg);
+
+      const incomingTxCount = Object.keys(msg.new).reduce(
+        (acc, sessionID) =>
+          acc + msg.new[sessionID as SessionID]!.newTransactions.length,
+        0,
+      );
+      expect(IDBClient.prototype.addTransaction).toBeCalledTimes(
+        incomingTxCount,
+      );
+
+      expect(syncManager.sendStateMessage).not.toBeCalled();
+    });
+
+    test("Sends correction message when peer sends a message far ahead of our state due to invalid assumption", async () => {
+      IDBClient.prototype.getCoValue.mockResolvedValueOnce({
+        id: coValueIdToLoad,
+        header: coValueHeader,
+        rowID: 3,
+      });
+      IDBClient.prototype.getCoValueSessions.mockResolvedValueOnce(
+        sessionsData,
+      );
+
+      const farAheadContentMessage = fixtures[coValueIdToLoad].getContent({
+        after: 10000,
+      });
+      await syncManager.handleSyncMessage(
+        farAheadContentMessage as SyncMessage,
+      );
+
+      expect(syncManager.sendStateMessage).toBeCalledWith({
+        action: "known",
+        header: true,
+        id: coValueIdToLoad,
+        isCorrection: true,
+        sessions: expect.any(Object),
+      });
+    });
+  });
+});

package/dist/tests/index.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.test.js","sourceRoot":"","sources":["../../src/tests/index.test.ts"],"names":[],"mappings":"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"}