cojson 0.8.12 → 0.8.16

package/src/tests/PeerKnownStates.test.ts

@@ -1,47 +1,51 @@
-import { PeerKnownStates } from '../PeerKnownStates.js';
-import { CoValueKnownState, emptyKnownState } from '../sync.js';
-import { RawCoID, SessionID } from '../ids.js';
-import { vi, describe, test, expect } from 'vitest';
+import { describe, expect, test, vi } from "vitest";
+import { PeerKnownStates } from "../PeerKnownStates.js";
+import { RawCoID, SessionID } from "../ids.js";
+import { CoValueKnownState, emptyKnownState } from "../sync.js";
 
-
-describe('PeerKnownStates', () => {
-  test('should set and get a known state', () => {
+describe("PeerKnownStates", () => {
+  test("should set and get a known state", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
+    const id = "test-id" as RawCoID;
     const knownState: CoValueKnownState = emptyKnownState(id);
 
-    peerKnownStates.dispatch({ type: 'SET', id, value: knownState });
+    peerKnownStates.dispatch({ type: "SET", id, value: knownState });
 
     expect(peerKnownStates.get(id)).toEqual(knownState);
     expect(peerKnownStates.has(id)).toBe(true);
   });
 
-  test('should update header', () => {
+  test("should update header", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
+    const id = "test-id" as RawCoID;
 
-    peerKnownStates.dispatch({ type: 'UPDATE_HEADER', id, header: true });
+    peerKnownStates.dispatch({ type: "UPDATE_HEADER", id, header: true });
 
     const result = peerKnownStates.get(id);
     expect(result?.header).toBe(true);
   });
 
-  test('should update session counter', () => {
+  test("should update session counter", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
-    const sessionId = 'session-1' as SessionID;
+    const id = "test-id" as RawCoID;
+    const sessionId = "session-1" as SessionID;
 
-    peerKnownStates.dispatch({ type: 'UPDATE_SESSION_COUNTER', id, sessionId, value: 5 });
+    peerKnownStates.dispatch({
+      type: "UPDATE_SESSION_COUNTER",
+      id,
+      sessionId,
+      value: 5,
+    });
 
     const result = peerKnownStates.get(id);
     expect(result?.sessions[sessionId]).toBe(5);
   });
 
-  test('should combine with existing state', () => {
+  test("should combine with existing state", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
-    const session1 = 'session-1' as SessionID;
-    const session2 = 'session-2' as SessionID;
+    const id = "test-id" as RawCoID;
+    const session1 = "session-1" as SessionID;
+    const session2 = "session-2" as SessionID;
     const initialState: CoValueKnownState = {
       ...emptyKnownState(id),
       sessions: { [session1]: 5 },
@@ -51,50 +55,50 @@ describe('PeerKnownStates', () => {
       sessions: { [session2]: 10 },
     };
 
-    peerKnownStates.dispatch({ type: 'SET', id, value: initialState });
-    peerKnownStates.dispatch({ type: 'COMBINE_WITH', id, value: combineState });
+    peerKnownStates.dispatch({ type: "SET", id, value: initialState });
+    peerKnownStates.dispatch({ type: "COMBINE_WITH", id, value: combineState });
 
     const result = peerKnownStates.get(id);
     expect(result?.sessions).toEqual({ [session1]: 5, [session2]: 10 });
   });
 
-  test('should set as empty', () => {
+  test("should set as empty", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
-    const sessionId = 'session-1' as SessionID;
+    const id = "test-id" as RawCoID;
+    const sessionId = "session-1" as SessionID;
     const initialState: CoValueKnownState = {
       ...emptyKnownState(id),
       sessions: { [sessionId]: 5 },
     };
 
-    peerKnownStates.dispatch({ type: 'SET', id, value: initialState });
-    peerKnownStates.dispatch({ type: 'SET_AS_EMPTY', id });
+    peerKnownStates.dispatch({ type: "SET", id, value: initialState });
+    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
 
     const result = peerKnownStates.get(id);
     expect(result).toEqual(emptyKnownState(id));
   });
 
-  test('should trigger listeners on dispatch', () => {
+  test("should trigger listeners on dispatch", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
+    const id = "test-id" as RawCoID;
     const listener = vi.fn();
 
     peerKnownStates.subscribe(listener);
-    peerKnownStates.dispatch({ type: 'SET_AS_EMPTY', id });
+    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
 
     expect(listener).toHaveBeenCalledWith(id, emptyKnownState(id));
   });
 
-  test('should unsubscribe listener', () => {
+  test("should unsubscribe listener", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
+    const id = "test-id" as RawCoID;
     const listener = vi.fn();
 
     const unsubscribe = peerKnownStates.subscribe(listener);
     unsubscribe();
 
-    peerKnownStates.dispatch({ type: 'SET_AS_EMPTY', id });
+    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
 
     expect(listener).not.toHaveBeenCalled();
   });
-});
+});

package/src/tests/PeerState.test.ts

@@ -1,81 +1,118 @@
-import { describe, test, expect, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { PeerState } from "../PeerState.js";
-import { Peer, SyncMessage } from "../sync.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
+import { Peer, SyncMessage } from "../sync.js";
 
 function setup() {
-    const mockPeer: Peer = {
-        id: "test-peer",
-        role: "peer",
-        priority: 1,
-        crashOnClose: false,
-        incoming: (async function* () {})(),
-        outgoing: {
-            push: vi.fn().mockResolvedValue(undefined),
-            close: vi.fn(),
-        },
-    };
-    const peerState = new PeerState(mockPeer);
-    return { mockPeer, peerState };
+  const mockPeer: Peer = {
+    id: "test-peer",
+    role: "peer",
+    priority: 1,
+    crashOnClose: false,
+    incoming: (async function* () {})(),
+    outgoing: {
+      push: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn(),
+    },
+  };
+  const peerState = new PeerState(mockPeer);
+  return { mockPeer, peerState };
 }
 
 describe("PeerState", () => {
-    test("should push outgoing message to peer", async () => {
-        const { mockPeer, peerState } = setup();
-        const message: SyncMessage = { action: "load", id: "co_ztest-id", header: false, sessions: {} };
-        await peerState.pushOutgoingMessage(message);
-        expect(mockPeer.outgoing.push).toHaveBeenCalledWith(message);
-    });
+  test("should push outgoing message to peer", async () => {
+    const { mockPeer, peerState } = setup();
+    const message: SyncMessage = {
+      action: "load",
+      id: "co_ztest-id",
+      header: false,
+      sessions: {},
+    };
+    await peerState.pushOutgoingMessage(message);
+    expect(mockPeer.outgoing.push).toHaveBeenCalledWith(message);
+  });
 
-    test("should return peer's incoming when not closed", () => {
-        const { mockPeer, peerState } = setup();
-        expect(peerState.incoming).toBe(mockPeer.incoming);
-    });
+  test("should return peer's incoming when not closed", () => {
+    const { mockPeer, peerState } = setup();
+    expect(peerState.incoming).toBe(mockPeer.incoming);
+  });
 
-    test("should return Disconnected when closed", async () => {
-        const { peerState } = setup();
-        peerState.gracefulShutdown();
-        const incomingIterator = peerState.incoming[Symbol.asyncIterator]();
-        const { value, done } = await incomingIterator.next();
-        expect(value).toBe("Disconnected");
-        expect(done).toBe(false);
-    });
+  test("should return Disconnected when closed", async () => {
+    const { peerState } = setup();
+    peerState.gracefulShutdown();
+    const incomingIterator = peerState.incoming[Symbol.asyncIterator]();
+    const { value, done } = await incomingIterator.next();
+    expect(value).toBe("Disconnected");
+    expect(done).toBe(false);
+  });
 
-    test("should perform graceful shutdown", () => {
-        const { mockPeer, peerState } = setup();
-        const consoleSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
-        peerState.gracefulShutdown();
-        expect(mockPeer.outgoing.close).toHaveBeenCalled();
-        expect(peerState.closed).toBe(true);
-        expect(consoleSpy).toHaveBeenCalledWith("Gracefully closing", "test-peer");
-        consoleSpy.mockRestore();
-    });
+  test("should perform graceful shutdown", () => {
+    const { mockPeer, peerState } = setup();
+    const consoleSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+    peerState.gracefulShutdown();
+    expect(mockPeer.outgoing.close).toHaveBeenCalled();
+    expect(peerState.closed).toBe(true);
+    expect(consoleSpy).toHaveBeenCalledWith("Gracefully closing", "test-peer");
+    consoleSpy.mockRestore();
+  });
 
-    test("should schedule outgoing messages based on their priority", async () => {
-        const { peerState } = setup();
+  test("should schedule outgoing messages based on their priority", async () => {
+    const { peerState } = setup();
 
-        const loadMessage: SyncMessage = { action: "load", id: "co_zhigh", header: false, sessions: {} };
-        const contentMessageHigh: SyncMessage = { action: "content", id: "co_zhigh", new: {}, priority: CO_VALUE_PRIORITY.HIGH };
-        const contentMessageMid: SyncMessage = { action: "content", id: "co_zmid", new: {}, priority: CO_VALUE_PRIORITY.MEDIUM };
-        const contentMessageLow: SyncMessage = { action: "content", id: "co_zlow", new: {}, priority: CO_VALUE_PRIORITY.LOW };
+    const loadMessage: SyncMessage = {
+      action: "load",
+      id: "co_zhigh",
+      header: false,
+      sessions: {},
+    };
+    const contentMessageHigh: SyncMessage = {
+      action: "content",
+      id: "co_zhigh",
+      new: {},
+      priority: CO_VALUE_PRIORITY.HIGH,
+    };
+    const contentMessageMid: SyncMessage = {
+      action: "content",
+      id: "co_zmid",
+      new: {},
+      priority: CO_VALUE_PRIORITY.MEDIUM,
+    };
+    const contentMessageLow: SyncMessage = {
+      action: "content",
+      id: "co_zlow",
+      new: {},
+      priority: CO_VALUE_PRIORITY.LOW,
+    };
 
-        const promises = [
-            peerState.pushOutgoingMessage(contentMessageLow),
-            peerState.pushOutgoingMessage(contentMessageMid),
-            peerState.pushOutgoingMessage(contentMessageHigh),
-            peerState.pushOutgoingMessage(loadMessage),
-        ];
+    const promises = [
+      peerState.pushOutgoingMessage(contentMessageLow),
+      peerState.pushOutgoingMessage(contentMessageMid),
+      peerState.pushOutgoingMessage(contentMessageHigh),
+      peerState.pushOutgoingMessage(loadMessage),
+    ];
 
-        await Promise.all(promises);
+    await Promise.all(promises);
 
-        // The first message is pushed directly, the other three are queued because are waiting
-        // for the first push to be completed.
-        expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(1, contentMessageLow); 
+    // The first message is pushed directly, the other three are queued because are waiting
+    // for the first push to be completed.
+    expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(
+      1,
+      contentMessageLow,
+    );
 
-        // Load message are managed as high priority messages and having the same priority as the content message
-        // they follow the push order.
-        expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(2, contentMessageHigh);
-        expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(3, loadMessage);
-        expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(4, contentMessageMid);
-    });
+    // Load message are managed as high priority messages and having the same priority as the content message
+    // they follow the push order.
+    expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(
+      2,
+      contentMessageHigh,
+    );
+    expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(
+      3,
+      loadMessage,
+    );
+    expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(
+      4,
+      contentMessageMid,
+    );
+  });
 });

package/src/tests/PriorityBasedMessageQueue.test.ts

@@ -1,111 +1,111 @@
-import { describe, test, expect } from "vitest";
+import { describe, expect, test } from "vitest";
 import { PriorityBasedMessageQueue } from "../PriorityBasedMessageQueue.js";
-import { SyncMessage } from "../sync.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
+import { SyncMessage } from "../sync.js";
 
 function setup() {
-    const queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.MEDIUM);
-    return { queue };
+  const queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.MEDIUM);
+  return { queue };
 }
 
 describe("PriorityBasedMessageQueue", () => {
-    test("should initialize with correct properties", () => {
-        const { queue } = setup();
-        expect(queue["defaultPriority"]).toBe(CO_VALUE_PRIORITY.MEDIUM);
-        expect(queue["queues"].length).toBe(8);
-        expect(queue["queues"].every((q) => q.length === 0)).toBe(true);
-    });
+  test("should initialize with correct properties", () => {
+    const { queue } = setup();
+    expect(queue["defaultPriority"]).toBe(CO_VALUE_PRIORITY.MEDIUM);
+    expect(queue["queues"].length).toBe(8);
+    expect(queue["queues"].every((q) => q.length === 0)).toBe(true);
+  });
 
-    test("should push message with default priority", async () => {
-        const { queue } = setup();
-        const message: SyncMessage = {
-            action: "load",
-            id: "co_ztest-id",
-            header: false,
-            sessions: {},
-        };
-        void queue.push(message);
-        const pulledEntry = queue.pull();
-        expect(pulledEntry?.msg).toEqual(message);
-    });
+  test("should push message with default priority", async () => {
+    const { queue } = setup();
+    const message: SyncMessage = {
+      action: "load",
+      id: "co_ztest-id",
+      header: false,
+      sessions: {},
+    };
+    void queue.push(message);
+    const pulledEntry = queue.pull();
+    expect(pulledEntry?.msg).toEqual(message);
+  });
 
-    test("should push message with specified priority", async () => {
-        const { queue } = setup();
-        const message: SyncMessage = {
-            action: "content",
-            id: "co_zhigh",
-            new: {},
-            priority: CO_VALUE_PRIORITY.HIGH,
-        };
-        void queue.push(message);
-        const pulledEntry = queue.pull();
-        expect(pulledEntry?.msg).toEqual(message);
-    });
+  test("should push message with specified priority", async () => {
+    const { queue } = setup();
+    const message: SyncMessage = {
+      action: "content",
+      id: "co_zhigh",
+      new: {},
+      priority: CO_VALUE_PRIORITY.HIGH,
+    };
+    void queue.push(message);
+    const pulledEntry = queue.pull();
+    expect(pulledEntry?.msg).toEqual(message);
+  });
 
-    test("should pull messages in priority order", async () => {
-        const { queue } = setup();
-        const lowPriorityMsg: SyncMessage = {
-            action: "content",
-            id: "co_zlow",
-            new: {},
-            priority: CO_VALUE_PRIORITY.LOW,
-        };
-        const mediumPriorityMsg: SyncMessage = {
-            action: "content",
-            id: "co_zmedium",
-            new: {},
-            priority: CO_VALUE_PRIORITY.MEDIUM,
-        };
-        const highPriorityMsg: SyncMessage = {
-            action: "content",
-            id: "co_zhigh",
-            new: {},
-            priority: CO_VALUE_PRIORITY.HIGH,
-        };
+  test("should pull messages in priority order", async () => {
+    const { queue } = setup();
+    const lowPriorityMsg: SyncMessage = {
+      action: "content",
+      id: "co_zlow",
+      new: {},
+      priority: CO_VALUE_PRIORITY.LOW,
+    };
+    const mediumPriorityMsg: SyncMessage = {
+      action: "content",
+      id: "co_zmedium",
+      new: {},
+      priority: CO_VALUE_PRIORITY.MEDIUM,
+    };
+    const highPriorityMsg: SyncMessage = {
+      action: "content",
+      id: "co_zhigh",
+      new: {},
+      priority: CO_VALUE_PRIORITY.HIGH,
+    };
 
-        void queue.push(lowPriorityMsg);
-        void queue.push(mediumPriorityMsg);
-        void queue.push(highPriorityMsg);
+    void queue.push(lowPriorityMsg);
+    void queue.push(mediumPriorityMsg);
+    void queue.push(highPriorityMsg);
 
-        expect(queue.pull()?.msg).toEqual(highPriorityMsg);
-        expect(queue.pull()?.msg).toEqual(mediumPriorityMsg);
-        expect(queue.pull()?.msg).toEqual(lowPriorityMsg);
-    });
+    expect(queue.pull()?.msg).toEqual(highPriorityMsg);
+    expect(queue.pull()?.msg).toEqual(mediumPriorityMsg);
+    expect(queue.pull()?.msg).toEqual(lowPriorityMsg);
+  });
 
-    test("should return undefined when pulling from empty queue", () => {
-        const { queue } = setup();
-        expect(queue.pull()).toBeUndefined();
-    });
+  test("should return undefined when pulling from empty queue", () => {
+    const { queue } = setup();
+    expect(queue.pull()).toBeUndefined();
+  });
 
-    test("should resolve promise when message is pulled", async () => {
-        const { queue } = setup();
-        const message: SyncMessage = {
-            action: "load",
-            id: "co_ztest-id",
-            header: false,
-            sessions: {},
-        };
-        const pushPromise = queue.push(message);
+  test("should resolve promise when message is pulled", async () => {
+    const { queue } = setup();
+    const message: SyncMessage = {
+      action: "load",
+      id: "co_ztest-id",
+      header: false,
+      sessions: {},
+    };
+    const pushPromise = queue.push(message);
 
-        const pulledEntry = queue.pull();
-        pulledEntry?.resolve();
+    const pulledEntry = queue.pull();
+    pulledEntry?.resolve();
 
-        await expect(pushPromise).resolves.toBeUndefined();
-    });
+    await expect(pushPromise).resolves.toBeUndefined();
+  });
 
-    test("should reject promise when message is rejected", async () => {
-        const { queue } = setup();
-        const message: SyncMessage = {
-            action: "load",
-            id: "co_ztest-id",
-            header: false,
-            sessions: {},
-        };
-        const pushPromise = queue.push(message);
+  test("should reject promise when message is rejected", async () => {
+    const { queue } = setup();
+    const message: SyncMessage = {
+      action: "load",
+      id: "co_ztest-id",
+      header: false,
+      sessions: {},
+    };
+    const pushPromise = queue.push(message);
 
-        const pulledEntry = queue.pull();
-        pulledEntry?.reject(new Error("Test error"));
+    const pulledEntry = queue.pull();
+    pulledEntry?.reject(new Error("Test error"));
 
-        await expect(pushPromise).rejects.toThrow("Test error");
-    });
+    await expect(pushPromise).rejects.toThrow("Test error");
+  });
 });

package/src/tests/account.test.ts

@@ -1,76 +1,76 @@
 import { expect, test } from "vitest";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { connectedPeers } from "../streamUtils.js";
-import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
 const Crypto = await WasmCrypto.create();
 
 test("Can create a node while creating a new account with profile", async () => {
-    const { node, accountID, accountSecret, sessionID } =
-        await LocalNode.withNewlyCreatedAccount({
-            creationProps: { name: "Hermes Puggington" },
-            crypto: Crypto,
-        });
-
-    expect(node).not.toBeNull();
-    expect(accountID).not.toBeNull();
-    expect(accountSecret).not.toBeNull();
-    expect(sessionID).not.toBeNull();
-
-    expect(node.expectProfileLoaded(accountID).get("name")).toEqual(
-        "Hermes Puggington",
-    );
-});
-
-test("A node with an account can create groups and and objects within them", async () => {
-    const { node, accountID } = await LocalNode.withNewlyCreatedAccount({
-        creationProps: { name: "Hermes Puggington" },
-        crypto: Crypto,
+  const { node, accountID, accountSecret, sessionID } =
+    await LocalNode.withNewlyCreatedAccount({
+      creationProps: { name: "Hermes Puggington" },
+      crypto: Crypto,
     });
 
-    const group = await node.createGroup();
-    expect(group).not.toBeNull();
+  expect(node).not.toBeNull();
+  expect(accountID).not.toBeNull();
+  expect(accountSecret).not.toBeNull();
+  expect(sessionID).not.toBeNull();
+
+  expect(node.expectProfileLoaded(accountID).get("name")).toEqual(
+    "Hermes Puggington",
+  );
+});
 
-    const map = group.createMap();
-    map.set("foo", "bar", "private");
-    expect(map.get("foo")).toEqual("bar");
-    expect(map.lastEditAt("foo")?.by).toEqual(accountID);
+test("A node with an account can create groups and and objects within them", async () => {
+  const { node, accountID } = await LocalNode.withNewlyCreatedAccount({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  const group = await node.createGroup();
+  expect(group).not.toBeNull();
+
+  const map = group.createMap();
+  map.set("foo", "bar", "private");
+  expect(map.get("foo")).toEqual("bar");
+  expect(map.lastEditAt("foo")?.by).toEqual(accountID);
 });
 
 test("Can create account with one node, and then load it on another", async () => {
-    const { node, accountID, accountSecret } =
-        await LocalNode.withNewlyCreatedAccount({
-            creationProps: { name: "Hermes Puggington" },
-            crypto: Crypto,
-        });
-
-    const group = await node.createGroup();
-    expect(group).not.toBeNull();
-
-    const map = group.createMap();
-    map.set("foo", "bar", "private");
-    expect(map.get("foo")).toEqual("bar");
-
-    const [node1asPeer, node2asPeer] = connectedPeers("node1", "node2", {
-        trace: true,
-        peer1role: "server",
-        peer2role: "client",
-    })
-
-    console.log("After connected peers");
-
-    node.syncManager.addPeer(node2asPeer);
-
-    const node2 = await LocalNode.withLoadedAccount({
-        accountID,
-        accountSecret,
-        sessionID: Crypto.newRandomSessionID(accountID),
-        peersToLoadFrom: [node1asPeer],
-        crypto: Crypto,
+  const { node, accountID, accountSecret } =
+    await LocalNode.withNewlyCreatedAccount({
+      creationProps: { name: "Hermes Puggington" },
+      crypto: Crypto,
     });
 
-    const map2 = await node2.load(map.id);
-    if (map2 === "unavailable") throw new Error("Map unavailable");
+  const group = await node.createGroup();
+  expect(group).not.toBeNull();
+
+  const map = group.createMap();
+  map.set("foo", "bar", "private");
+  expect(map.get("foo")).toEqual("bar");
+
+  const [node1asPeer, node2asPeer] = connectedPeers("node1", "node2", {
+    trace: true,
+    peer1role: "server",
+    peer2role: "client",
+  });
+
+  console.log("After connected peers");
+
+  node.syncManager.addPeer(node2asPeer);
+
+  const node2 = await LocalNode.withLoadedAccount({
+    accountID,
+    accountSecret,
+    sessionID: Crypto.newRandomSessionID(accountID),
+    peersToLoadFrom: [node1asPeer],
+    crypto: Crypto,
+  });
+
+  const map2 = await node2.load(map.id);
+  if (map2 === "unavailable") throw new Error("Map unavailable");
 
-    expect(map2.get("foo")).toEqual("bar");
+  expect(map2.get("foo")).toEqual("bar");
 });