jazz-tools 0.19.11 → 0.19.13

package/src/browser/provideBrowserLockSession/BrowserSessionProvider.test.ts

@@ -0,0 +1,406 @@
+// @vitest-environment happy-dom
+
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
+import { SessionID } from "cojson";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { BrowserSessionProvider } from "./BrowserSessionProvider.js";
+import { SessionIDStorage } from "./SessionIDStorage.js";
+import { createJazzTestAccount } from "jazz-tools/testing";
+import type { CryptoProvider } from "jazz-tools";
+
+const Crypto = await WasmCrypto.create();
+
+// Mock navigator.locks
+interface LockInfo {
+  mode: "exclusive" | "shared";
+  release: () => void;
+}
+
+const mockLocks = new Map<string, LockInfo>();
+
+function isLockAvailable(
+  name: string,
+  requestedMode: "exclusive" | "shared",
+): boolean {
+  const existingLock = mockLocks.get(name);
+  if (!existingLock) {
+    return true; // No existing lock
+  }
+
+  // Exclusive locks block everything
+  if (existingLock.mode === "exclusive" || requestedMode === "exclusive") {
+    return false;
+  }
+
+  // Shared locks can coexist with other shared locks
+  if (existingLock.mode === "shared" && requestedMode === "shared") {
+    return true;
+  }
+
+  return false;
+}
+
+function createMockLock(
+  name: string,
+  mode: "exclusive" | "shared",
+): {
+  lock: { name: string } | null;
+  release: () => void;
+} {
+  if (!isLockAvailable(name, mode)) {
+    return { lock: null, release: () => {} };
+  }
+
+  // Create new lock
+  const lockInfo: LockInfo = {
+    mode,
+    release: () => {
+      mockLocks.delete(name);
+    },
+  };
+
+  mockLocks.set(name, lockInfo);
+
+  return {
+    lock: { name },
+    release: lockInfo.release,
+  };
+}
+
+vi.stubGlobal("navigator", {
+  locks: {
+    request: vi.fn(
+      async (
+        name: string,
+        options: { mode?: "exclusive" | "shared"; ifAvailable?: boolean },
+        callback: (lock: { name: string } | null) => Promise<void> | void,
+      ) => {
+        const mode = options?.mode || "exclusive";
+        const ifAvailable = options?.ifAvailable || false;
+
+        if (ifAvailable) {
+          const { lock } = createMockLock(name, mode);
+          if (!lock) {
+            // Lock not available, call callback with null and return immediately
+            await callback(null);
+            return;
+          }
+          // Lock available, call callback with lock
+          // The lock is held until the promise returned from callback resolves
+          const callbackPromise = callback(lock);
+          const result = await callbackPromise;
+          // Release lock after callback promise resolves
+          mockLocks.get(name)?.release();
+          return result;
+        }
+
+        // For non-ifAvailable locks, wait until available
+        // In a real implementation, this would wait, but for tests we assume immediate availability
+        const { lock, release } = createMockLock(name, mode);
+        if (!lock) {
+          // This shouldn't happen in tests for non-ifAvailable locks
+          // But handle it gracefully
+          await callback(null);
+          return;
+        }
+
+        try {
+          const callbackPromise = callback(lock);
+          const result = await callbackPromise;
+          return result;
+        } finally {
+          release();
+        }
+      },
+    ),
+  },
+});
+
+describe("BrowserSessionProvider", () => {
+  let sessionProvider: BrowserSessionProvider;
+  let account: Awaited<ReturnType<typeof createJazzTestAccount>>;
+
+  beforeEach(async () => {
+    // Clear localStorage
+    localStorage.clear();
+
+    // Clear mock locks
+    mockLocks.clear();
+
+    // Create new session provider instance
+    sessionProvider = new BrowserSessionProvider();
+
+    // Create test account
+    account = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+  });
+
+  describe("acquireSession", () => {
+    test("creates new session when none exists", async () => {
+      const accountID = account.$jazz.id;
+
+      // Verify no sessions exist
+      const existingSessionsBefore =
+        SessionIDStorage.getSessionsList(accountID);
+      expect(existingSessionsBefore).toEqual([]);
+
+      // Acquire session
+      const result = await sessionProvider.acquireSession(
+        accountID,
+        Crypto as CryptoProvider,
+      );
+
+      // Verify a new session ID is generated
+      expect(result.sessionID).toBeDefined();
+
+      // Verify the session is stored in localStorage
+      const storedSessions = SessionIDStorage.getSessionsList(accountID);
+      expect(storedSessions).toHaveLength(1);
+      expect(storedSessions[0]).toBe(result.sessionID);
+    });
+
+    test("returns existing session when available", async () => {
+      const accountID = account.$jazz.id;
+      const existingSessionID = "existing-session-id" as SessionID;
+
+      // Pre-populate localStorage with a session ID
+      SessionIDStorage.storeSessionID(accountID, existingSessionID, 0);
+
+      // Verify session exists before calling acquireSession
+      const sessionsBefore = SessionIDStorage.getSessionsList(accountID);
+      expect(sessionsBefore).toHaveLength(1);
+      expect(sessionsBefore[0]).toBe(existingSessionID);
+
+      // Acquire session
+      const result = await sessionProvider.acquireSession(
+        accountID,
+        Crypto as CryptoProvider,
+      );
+
+      // Verify the existing session ID is returned (not a new one)
+      expect(result.sessionID).toBe(existingSessionID);
+
+      // Verify no new session is created (same value still in store)
+      const sessionsAfter = SessionIDStorage.getSessionsList(accountID);
+      expect(sessionsAfter).toHaveLength(1);
+      expect(sessionsAfter[0]).toBe(existingSessionID);
+      expect(sessionsAfter[0]).toBe(result.sessionID);
+    });
+
+    test("handles multiple sessions in list - skips locked sessions and returns next available", async () => {
+      const accountID = account.$jazz.id;
+      const session1 = "session-1" as SessionID;
+      const session2 = "session-2" as SessionID;
+      const session3 = "session-3" as SessionID;
+
+      // Pre-populate localStorage with multiple sessions
+      SessionIDStorage.storeSessionID(accountID, session1, 0);
+      SessionIDStorage.storeSessionID(accountID, session2, 1);
+      SessionIDStorage.storeSessionID(accountID, session3, 2);
+
+      // Verify sessions are stored
+      const sessionsBefore = SessionIDStorage.getSessionsList(accountID);
+      expect(sessionsBefore).toHaveLength(3);
+
+      // Lock the first session (index 0) by manually adding it to mockLocks
+      const lockName = `load_session_${session1}`;
+      mockLocks.set(lockName, {
+        mode: "exclusive",
+        release: () => {
+          mockLocks.delete(lockName);
+        },
+      });
+
+      // Acquire session - should skip locked session1 and return session2
+      const result = await sessionProvider.acquireSession(
+        accountID,
+        Crypto as CryptoProvider,
+      );
+
+      // Verify it returned session2 (next available, not session1 which is locked)
+      expect(result.sessionID).toBe(session2);
+
+      // Verify the returned session is from the existing list, not a new one
+      const allSessions = SessionIDStorage.getSessionsList(accountID);
+      expect(allSessions).toContain(result.sessionID);
+      expect([session1, session2, session3]).toContain(result.sessionID);
+
+      // Clean up the held lock
+      mockLocks.delete(lockName);
+    });
+
+    test("creates new session when all existing sessions are locked", async () => {
+      const accountID = account.$jazz.id;
+      const session1 = "session-1" as SessionID;
+      const session2 = "session-2" as SessionID;
+
+      // Pre-populate localStorage with sessions
+      SessionIDStorage.storeSessionID(accountID, session1, 0);
+      SessionIDStorage.storeSessionID(accountID, session2, 1);
+
+      // Verify sessions are stored
+      const sessionsBefore = SessionIDStorage.getSessionsList(accountID);
+      expect(sessionsBefore).toHaveLength(2);
+
+      // Lock all existing sessions by manually adding them to mockLocks
+      const lock1Name = `load_session_${session1}`;
+      const lock2Name = `load_session_${session2}`;
+      mockLocks.set(lock1Name, {
+        mode: "exclusive",
+        release: () => {
+          mockLocks.delete(lock1Name);
+        },
+      });
+      mockLocks.set(lock2Name, {
+        mode: "exclusive",
+        release: () => {
+          mockLocks.delete(lock2Name);
+        },
+      });
+
+      // Acquire session - should create a new one since all existing are locked
+      const result = await sessionProvider.acquireSession(
+        accountID,
+        Crypto as CryptoProvider,
+      );
+
+      // Verify a new session is created (not one of the existing locked ones)
+      expect(result.sessionID).not.toBe(session1);
+      expect(result.sessionID).not.toBe(session2);
+
+      // Verify the new session is added to localStorage
+      const sessionsAfter = SessionIDStorage.getSessionsList(accountID);
+      expect(sessionsAfter).toHaveLength(3);
+      expect(sessionsAfter).toContain(result.sessionID);
+
+      // Clean up held locks
+      mockLocks.delete(lock1Name);
+      mockLocks.delete(lock2Name);
+    });
+
+    test("releases lock when sessionDone is called", async () => {
+      const accountID = account.$jazz.id;
+
+      // Acquire a session
+      const result = await sessionProvider.acquireSession(
+        accountID,
+        Crypto as CryptoProvider,
+      );
+
+      const sessionID = result.sessionID;
+
+      // Call sessionDone to release the lock
+      result.sessionDone();
+
+      // Wait for async lock release
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      // Acquire a session
+      const result2 = await sessionProvider.acquireSession(
+        accountID,
+        Crypto as CryptoProvider,
+      );
+
+      expect(result2.sessionID).toBe(sessionID);
+    });
+  });
+
+  describe("persistSession", () => {
+    test("stores session ID correctly", async () => {
+      const accountID = account.$jazz.id;
+      const sessionID = "test-session-id" as SessionID;
+
+      // Verify no sessions exist before
+      const sessionsBefore = SessionIDStorage.getSessionsList(accountID);
+      expect(sessionsBefore).toEqual([]);
+
+      // Persist session
+      const result = await sessionProvider.persistSession(accountID, sessionID);
+
+      // Verify the session ID is stored in localStorage at index 0
+      const storedSessions = SessionIDStorage.getSessionsList(accountID);
+      expect(storedSessions).toHaveLength(1);
+      expect(storedSessions[0]).toBe(sessionID);
+
+      // Verify sessionDone callback is provided
+      expect(typeof result.sessionDone).toBe("function");
+    });
+
+    test("adds to sessions list properly", async () => {
+      const accountID = account.$jazz.id;
+      const initialSessionID = "initial-session-id" as SessionID;
+      const newSessionID = "new-session-id" as SessionID;
+
+      // Pre-populate localStorage with one session (index 0)
+      SessionIDStorage.storeSessionID(accountID, initialSessionID, 0);
+
+      // Verify initial session is stored
+      const sessionsBefore = SessionIDStorage.getSessionsList(accountID);
+      expect(sessionsBefore).toHaveLength(1);
+      expect(sessionsBefore[0]).toBe(initialSessionID);
+
+      // Persist a new session ID
+      await sessionProvider.persistSession(accountID, newSessionID);
+
+      // Verify the new session is stored at index 1
+      const sessionsAfter = SessionIDStorage.getSessionsList(accountID);
+      expect(sessionsAfter).toHaveLength(2);
+      expect(sessionsAfter[0]).toBe(initialSessionID);
+      expect(sessionsAfter[1]).toBe(newSessionID);
+    });
+
+    test("locks session when persisting", async () => {
+      const accountID = account.$jazz.id;
+      const sessionID = "persisted-session-id" as SessionID;
+
+      // Persist session - this should acquire a lock on the session
+      const { sessionDone } = await sessionProvider.persistSession(
+        accountID,
+        sessionID,
+      );
+
+      // Verify the session is locked by checking mockLocks directly
+      // The lock should be held until sessionDone is called
+      const lockName = `load_session_${sessionID}`;
+      expect(mockLocks.has(lockName)).toBe(true);
+
+      // Also verify we can't acquire the lock while it's held
+      // (This tests the isLockAvailable function)
+      expect(isLockAvailable(lockName, "exclusive")).toBe(false);
+
+      // Clean up by releasing the lock
+      sessionDone();
+
+      // After releasing, the lock should be removed
+      // Note: The lock might be removed asynchronously, so we check after a small delay
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(mockLocks.has(lockName)).toBe(false);
+    });
+
+    test("releases lock when sessionDone is called", async () => {
+      const accountID = account.$jazz.id;
+      const sessionID = "session-to-release" as SessionID;
+
+      // Persist a session
+      const { sessionDone } = await sessionProvider.persistSession(
+        accountID,
+        sessionID,
+      );
+
+      // Call sessionDone to release the lock
+      sessionDone();
+
+      // Wait for async lock release
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      // Acquire a session
+      const result = await sessionProvider.acquireSession(
+        accountID,
+        Crypto as CryptoProvider,
+      );
+
+      expect(result.sessionID).toBe(sessionID);
+    });
+  });
+});

package/src/browser/provideBrowserLockSession/BrowserSessionProvider.ts

@@ -0,0 +1,132 @@
+import { AgentID, CryptoProvider, RawAccountID, SessionID } from "cojson";
+import { ID, Account, SessionProvider } from "jazz-tools";
+import { SessionIDStorage } from "./SessionIDStorage";
+
+export class BrowserSessionProvider implements SessionProvider {
+  async acquireSession(
+    accountID: ID<Account> | AgentID,
+    crypto: CryptoProvider,
+  ): Promise<{ sessionID: SessionID; sessionDone: () => void }> {
+    const { sessionPromise, resolveSession } = createSessionLockPromise();
+
+    // Get the list of sessions for the account, to try to acquire an existing session
+    const sessionsList = SessionIDStorage.getSessionsList(accountID);
+
+    for (const [index, sessionID] of sessionsList.entries()) {
+      const sessionAcquired = await tryToAcquireSession(
+        sessionID,
+        sessionPromise,
+      );
+
+      if (sessionAcquired) {
+        console.log("Using existing session", sessionID, "at index", index); // This log is used in the e2e tests to verify the correctness of the feature
+        return {
+          sessionID,
+          sessionDone: resolveSession,
+        };
+      }
+    }
+
+    const newSessionID = crypto.newRandomSessionID(
+      accountID as RawAccountID | AgentID,
+    );
+
+    // Acquire exclusively the session to store the new session ID for reuse in future sessions
+    await lockAndStoreSession(accountID, newSessionID, sessionPromise);
+
+    console.log("Created new session", newSessionID); // This log is used in the e2e tests to verify the correctness of the feature
+
+    return {
+      sessionID: newSessionID,
+      sessionDone: resolveSession,
+    };
+  }
+
+  async persistSession(
+    accountID: ID<Account> | AgentID,
+    sessionID: SessionID,
+  ): Promise<{ sessionDone: () => void }> {
+    const { sessionPromise, resolveSession } = createSessionLockPromise();
+
+    // Store the session id for future use and lock it until the session is done
+    await lockAndStoreSession(accountID, sessionID, sessionPromise);
+
+    console.log("Stored new session", sessionID);
+
+    return { sessionDone: resolveSession };
+  }
+}
+
+async function lockAndStoreSession(
+  accountID: ID<Account> | AgentID,
+  sessionID: SessionID,
+  sessionPromise: Promise<void>,
+) {
+  const sessionAcquired = await tryToAcquireSession(sessionID, sessionPromise);
+
+  if (!sessionAcquired) {
+    // This should never happen because the session has been randomly generated
+    throw new Error("Couldn't get lock on new session");
+  }
+
+  // We don't need to wait for this to finish, we only need to acquire the lock on the new session
+  storeSessionID(accountID, sessionID);
+}
+
+function tryToAcquireSession(
+  sessionID: SessionID,
+  sessionDonePromise: Promise<void>,
+) {
+  return new Promise<boolean>((resolve) => {
+    // Acquire exclusively the session if available
+    navigator.locks.request(
+      `load_session_${sessionID}`,
+      { mode: "exclusive", ifAvailable: true },
+      async (lock) => {
+        if (!lock) {
+          resolve(false); // Session already in use
+          return;
+        }
+
+        resolve(true); // Session is available
+
+        // Return the promise to lock the session until sessionDone is called
+        return sessionDonePromise;
+      },
+    );
+  });
+}
+
+function storeSessionID(
+  accountID: ID<Account> | AgentID,
+  sessionID: SessionID,
+) {
+  return navigator.locks.request(
+    `store_session_${accountID}`,
+    { mode: "exclusive" },
+    async (lock) => {
+      if (!lock) {
+        console.error("Couldn't get lock to store session ID", accountID);
+      }
+
+      const sessionsList = SessionIDStorage.getSessionsList(accountID);
+      SessionIDStorage.storeSessionID(
+        accountID,
+        sessionID,
+        sessionsList.length,
+      );
+    },
+  );
+}
+
+function createSessionLockPromise() {
+  let resolveSession: () => void;
+  const sessionPromise = new Promise<void>((resolve) => {
+    resolveSession = resolve;
+  });
+
+  return {
+    sessionPromise,
+    resolveSession: resolveSession!,
+  };
+}

package/src/browser/provideBrowserLockSession/SessionIDStorage.ts

@@ -0,0 +1,33 @@
+import { SessionID } from "cojson";
+
+function getSessionKey(accountID: string, index: number) {
+  return accountID + "_" + index;
+}
+
+export class SessionIDStorage {
+  static getSessionsList(accountID: string) {
+    let sessionsList: SessionID[] = [];
+    let i = 0;
+    let lastSessionID: SessionID | null;
+
+    do {
+      lastSessionID = localStorage.getItem(
+        getSessionKey(accountID, i),
+      ) as SessionID | null;
+      if (lastSessionID) {
+        sessionsList.push(lastSessionID);
+      }
+      i++;
+    } while (lastSessionID);
+
+    return sessionsList;
+  }
+
+  static storeSessionID(
+    accountID: string,
+    sessionID: SessionID,
+    index: number,
+  ) {
+    localStorage.setItem(getSessionKey(accountID, index), sessionID);
+  }
+}

package/src/browser/provideBrowserLockSession/index.ts

@@ -0,0 +1,11 @@
+import { MockSessionProvider } from "jazz-tools";
+import { BrowserSessionProvider } from "./BrowserSessionProvider";
+
+export function getBrowserLockSessionProvider() {
+  if (typeof navigator === "undefined" || !navigator.locks?.request) {
+    // Fallback to random session ID for each tab session
+    return new MockSessionProvider();
+  }
+
+  return new BrowserSessionProvider();
+}

package/src/inspector/tests/utils/transactions-changes.test.ts

@@ -0,0 +1,102 @@
+import { assert, describe, expect, it } from "vitest";
+import { setActiveAccount, setupJazzTestSync } from "jazz-tools/testing";
+import { co, z } from "jazz-tools";
+import * as TransactionsChanges from "../../utils/transactions-changes";
+
+describe("transactions changes", async () => {
+  const account = await setupJazzTestSync();
+  setActiveAccount(account);
+
+  describe("ambiguous values in Group's transactions", () => {
+    it("isGroupExtension should return false for a CoMap", () => {
+      const value = co.map({ test: z.string() }).create({ test: "extend" })
+        .$jazz.raw;
+
+      const transactions = value.core.verifiedTransactions;
+      expect(
+        TransactionsChanges.isGroupExtension(
+          value,
+          transactions[0]?.changes?.[0],
+        ),
+      ).toBe(false);
+    });
+
+    it("isGroupExtendRevocation should return false for a CoMap", () => {
+      const value = co.map({ test: z.string() }).create({ test: "revoked" })
+        .$jazz.raw;
+
+      const transactions = value.core.verifiedTransactions;
+      expect(
+        TransactionsChanges.isGroupExtendRevocation(
+          value,
+          transactions[0]?.changes?.[0],
+        ),
+      ).toBe(false);
+    });
+
+    it("isGroupPromotion should return false for a CoMap", () => {
+      const value = co
+        .map({ parent_co_test: z.string() })
+        .create({ parent_co_test: "foo" }).$jazz.raw;
+
+      const transactions = value.core.verifiedTransactions;
+      expect(
+        TransactionsChanges.isGroupPromotion(
+          value,
+          transactions[0]?.changes?.[0],
+        ),
+      ).toBe(false);
+    });
+
+    it("isUserPromotion should return false for a CoMap", () => {
+      const value = co.map({ everyone: z.string() }).create({ everyone: "foo" })
+        .$jazz.raw;
+
+      const transactions = value.core.verifiedTransactions;
+      expect(
+        TransactionsChanges.isUserPromotion(
+          value,
+          transactions[0]?.changes?.[0],
+        ),
+      ).toBe(false);
+    });
+
+    it("isUserPromotion should return false for a CoMap", () => {
+      const value = co.map({ everyone: z.string() }).create({ everyone: "foo" })
+        .$jazz.raw;
+
+      const transactions = value.core.verifiedTransactions;
+      expect(
+        TransactionsChanges.isUserPromotion(
+          value,
+          transactions[0]?.changes?.[0],
+        ),
+      ).toBe(false);
+
+      const value2 = co.map({ co_z123: z.string() }).create({ co_z123: "foo" })
+        .$jazz.raw;
+
+      const transactions2 = value2.core.verifiedTransactions;
+      expect(
+        TransactionsChanges.isUserPromotion(
+          value2,
+          transactions2[0]?.changes?.[0],
+        ),
+      ).toBe(false);
+    });
+
+    it("isKeyRevelation should return false for a CoMap", () => {
+      const value = co
+        .map({ "123_for_test": z.string() })
+        .create({ "123_for_test": "foo" }).$jazz.raw;
+
+      const transactions = value.core.verifiedTransactions;
+      expect(
+        TransactionsChanges.isKeyRevelation(
+          value,
+          transactions[0]?.changes?.[0],
+        ),
+      ).toBe(false);
+    });
+  });
+});

package/src/inspector/ui/icons/add-icon.tsx

@@ -12,9 +12,9 @@ export function AddIcon(props: React.SVGProps<SVGSVGElement>) {
     >
       <path
         d="M4 12H20M12 4V20"
-        stroke-width="2"
-        stroke-linecap="round"
-        stroke-linejoin="round"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
       />
     </svg>
   );