jazz-tools 0.19.8 → 0.19.11

package/src/tools/tests/ContextManager.test.ts

@@ -33,6 +33,7 @@ import {
   getPeerConnectedToTestSyncServer,
   setupJazzTestSync,
 } from "../testing";
+import { SubscriptionCache } from "../subscribe/SubscriptionCache";
 import { createAsyncStorage, getDbPath } from "./testStorage";
 
 const Crypto = await WasmCrypto.create();
@@ -809,4 +810,88 @@ describe("ContextManager", () => {
       );
     });
   });
+
+  describe("SubscriptionCache integration", () => {
+    test("initializes cache on construction", () => {
+      const newManager = new TestJazzContextManager<Account>();
+      const cache = newManager.getSubscriptionScopeCache();
+
+      expect(cache).toBeDefined();
+      expect(cache).toBeInstanceOf(SubscriptionCache);
+    });
+
+    test("getSubscriptionScopeCache returns the cache instance", () => {
+      const cache1 = manager.getSubscriptionScopeCache();
+      const cache2 = manager.getSubscriptionScopeCache();
+
+      expect(cache1).toBe(cache2);
+      expect(cache1).toBeDefined();
+    });
+
+    test("updateContext clears the cache", async () => {
+      await manager.createContext({});
+
+      const cache = manager.getSubscriptionScopeCache();
+      const node = getCurrentValue().node;
+      const Person = co.map({ name: z.string() });
+      const person = Person.create({ name: "Test" });
+
+      // Create a subscription in the cache
+      const scope = cache.getOrCreate(
+        node,
+        Person,
+        person.$jazz.id,
+        true,
+        false,
+        false,
+      );
+
+      // Verify it's in the cache
+      const idSet = (cache as any).cache.get(person.$jazz.id);
+      expect(idSet).toBeDefined();
+      expect(idSet).toBeInstanceOf(Set);
+      expect(idSet.size).toBeGreaterThan(0);
+
+      // Update context - should clear cache
+      await manager.createContext({});
+
+      // Verify cache was cleared
+      const idSetAfter = (cache as any).cache.get(person.$jazz.id);
+      expect(idSetAfter).toBeUndefined();
+      expect(scope.closed).toBe(true);
+    });
+
+    test("logOut clears the cache", async () => {
+      await manager.createContext({});
+
+      const cache = manager.getSubscriptionScopeCache();
+      const node = getCurrentValue().node;
+      const Person = co.map({ name: z.string() });
+      const person = Person.create({ name: "Test" });
+
+      // Create a subscription in the cache
+      const scope = cache.getOrCreate(
+        node,
+        Person,
+        person.$jazz.id,
+        true,
+        false,
+        false,
+      );
+
+      // Verify it's in the cache
+      const scopeSet = (cache as any).cache.get(person.$jazz.id);
+      expect(scopeSet).toBeDefined();
+      expect(scopeSet).toBeInstanceOf(Set);
+      expect(scopeSet.size).toBeGreaterThan(0);
+
+      // Logout - should clear cache
+      await manager.logOut();
+
+      // Verify cache was cleared
+      const scopeSetAfter = (cache as any).cache.get(person.$jazz.id);
+      expect(scopeSetAfter).toBeUndefined();
+      expect(scope.closed).toBe(true);
+    });
+  });
 });

package/src/tools/tests/SubscriptionCache.test.ts

@@ -0,0 +1,237 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { Account, Group, co, z } from "../exports.js";
+import { SubscriptionCache } from "../subscribe/SubscriptionCache.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+
+describe("SubscriptionCache", () => {
+  const Person = co.map({
+    name: co.plainText(),
+  });
+
+  beforeEach(async () => {
+    await setupJazzTestSync();
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+  });
+
+  describe("cache key comparison logic", () => {
+    it("matches entries with identical schema, id, resolve, and branch", () => {
+      const person = Person.create({ name: "John" });
+      const node = person.$jazz.raw.core.node;
+      const id = person.$jazz.id;
+      const cache = new SubscriptionCache();
+
+      const scope1 = cache.getOrCreate(node, Person, id, true, false, false);
+      const scope2 = cache.getOrCreate(node, Person, id, true, false, false);
+
+      expect(scope1).toBe(scope2);
+      cache.clear();
+    });
+
+    it("creates different entries for different resolve queries", () => {
+      const person = Person.create({ name: "John" });
+      const node = person.$jazz.raw.core.node;
+      const id = person.$jazz.id;
+      const cache = new SubscriptionCache();
+
+      const scope1 = cache.getOrCreate(node, Person, id, true, false, false);
+      const scope2 = cache.getOrCreate(
+        node,
+        Person,
+        id,
+        { name: true },
+        false,
+        false,
+      );
+
+      expect(scope1).not.toBe(scope2);
+      cache.clear();
+    });
+
+    it("creates different entries for different branch definitions", () => {
+      const person = Person.create({ name: "John" });
+      const group = Group.create();
+      const node = person.$jazz.raw.core.node;
+      const id = person.$jazz.id;
+      const cache = new SubscriptionCache();
+
+      const scope1 = cache.getOrCreate(node, Person, id, true, false, false, {
+        name: "branch1",
+        owner: group,
+      });
+      const scope2 = cache.getOrCreate(node, Person, id, true, false, false, {
+        name: "branch2",
+        owner: group,
+      });
+
+      expect(scope1).not.toBe(scope2);
+      cache.clear();
+    });
+
+    it("matches entries with same branch name but different owner references", () => {
+      const person = Person.create({ name: "John" });
+      const group1 = Group.create();
+      const group2 = Group.create();
+      const node = person.$jazz.raw.core.node;
+      const id = person.$jazz.id;
+      const cache = new SubscriptionCache();
+
+      const scope1 = cache.getOrCreate(node, Person, id, true, false, false, {
+        name: "branch",
+        owner: group1,
+      });
+      const scope2 = cache.getOrCreate(node, Person, id, true, false, false, {
+        name: "branch",
+        owner: group2,
+      });
+
+      expect(scope1).not.toBe(scope2);
+      cache.clear();
+    });
+  });
+
+  describe("subscriber count tracking", () => {
+    it("tracks subscriber count changes via onSubscriberChange", () => {
+      const person = Person.create({ name: "John" });
+      const node = person.$jazz.raw.core.node;
+      const id = person.$jazz.id;
+      const cache = new SubscriptionCache();
+
+      const scope = cache.getOrCreate(node, Person, id, true, false, false);
+
+      expect(scope.subscribers.size).toBe(0);
+
+      const unsubscribe1 = scope.subscribe(() => {});
+      expect(scope.subscribers.size).toBe(1);
+
+      const unsubscribe2 = scope.subscribe(() => {});
+      expect(scope.subscribers.size).toBe(2);
+
+      unsubscribe1();
+      expect(scope.subscribers.size).toBe(1);
+
+      unsubscribe2();
+      expect(scope.subscribers.size).toBe(0);
+
+      cache.clear();
+    });
+  });
+
+  describe("cleanup lifecycle", () => {
+    it("schedules cleanup when subscriber count reaches zero", async () => {
+      vi.useFakeTimers();
+      const person = Person.create({ name: "John" });
+      const node = person.$jazz.raw.core.node;
+      const id = person.$jazz.id;
+      const cache = new SubscriptionCache(100); // 100ms timeout
+
+      const scope = cache.getOrCreate(node, Person, id, true, false, false);
+
+      const unsubscribe = scope.subscribe(() => {});
+      unsubscribe();
+
+      await vi.advanceTimersByTimeAsync(110);
+
+      expect(scope.closed).toBe(true);
+
+      cache.clear();
+      vi.useRealTimers();
+    });
+
+    it("cancels cleanup when new subscription arrives during pending cleanup", async () => {
+      vi.useFakeTimers();
+      const person = Person.create({ name: "John" });
+      const node = person.$jazz.raw.core.node;
+      const id = person.$jazz.id;
+      const cache = new SubscriptionCache(100); // 100ms timeout
+
+      const scope1 = cache.getOrCreate(node, Person, id, true, false, false);
+
+      const unsubscribe = scope1.subscribe(() => {});
+      unsubscribe();
+
+      await vi.advanceTimersByTimeAsync(50);
+
+      // Request again before cleanup
+      const scope2 = cache.getOrCreate(node, Person, id, true, false, false);
+
+      expect(scope2).toBe(scope1);
+      await vi.advanceTimersByTimeAsync(60);
+
+      cache.clear();
+      vi.useRealTimers();
+    });
+
+    it("executes cleanup after timeout", async () => {
+      vi.useFakeTimers();
+      const person = Person.create({ name: "John" });
+      const node = person.$jazz.raw.core.node;
+      const id = person.$jazz.id;
+      const cache = new SubscriptionCache(100); // 100ms timeout
+
+      const scope = cache.getOrCreate(node, Person, id, true, false, false);
+
+      const unsubscribe = scope.subscribe(() => {});
+      unsubscribe();
+
+      await vi.advanceTimersByTimeAsync(150);
+
+      const idSet = (cache as any).cache.get(id);
+      expect(idSet).toBeUndefined();
+
+      cache.clear();
+      vi.useRealTimers();
+    });
+  });
+
+  describe("clear method", () => {
+    it("destroys all entries", () => {
+      const person1 = Person.create({ name: "John" });
+      const person2 = Person.create({ name: "Jane" });
+      const node = person1.$jazz.raw.core.node;
+      const cache = new SubscriptionCache();
+
+      const scope1 = cache.getOrCreate(
+        node,
+        Person,
+        person1.$jazz.id,
+        true,
+        false,
+        false,
+      );
+      const scope2 = cache.getOrCreate(
+        node,
+        Person,
+        person2.$jazz.id,
+        true,
+        false,
+        false,
+      );
+
+      cache.clear();
+
+      expect(scope1.closed).toBe(true);
+      expect(scope2.closed).toBe(true);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("throws error for null/undefined id", () => {
+      const person = Person.create({ name: "John" });
+      const node = person.$jazz.raw.core.node;
+      const cache = new SubscriptionCache();
+
+      expect(() => {
+        cache.getOrCreate(node, Person, null as any, true, false, false);
+      }).toThrow("Cannot create subscription with undefined or null id");
+
+      expect(() => {
+        cache.getOrCreate(node, Person, undefined as any, true, false, false);
+      }).toThrow("Cannot create subscription with undefined or null id");
+
+      cache.clear();
+    });
+  });
+});

package/src/tools/tests/account.test.ts

@@ -467,7 +467,7 @@ describe("createAs", () => {
       { owner: worker },
     );
 
-    const createdAccount = await CustomAccount.createAs(worker, {
+    const created = await CustomAccount.createAs(worker, {
       creationProps: { name: "Test Account" },
       onCreate: async (account, loadedWorker) => {
         executionOrder.push("onCreate");
@@ -490,11 +490,18 @@ describe("createAs", () => {
       },
     });
 
-    assertLoaded(createdAccount);
-    assertLoaded(createdAccount.root);
+    assertLoaded(created.account);
+    assertLoaded(created.account.root);
+
+    expect(created.credentials.accountID).toBe(created.account.$jazz.id);
+    // ensure we get the created, not the creat*ing* account credentials
+    expect(created.credentials.accountID).not.toBe(worker.$jazz.id);
+    expect(created.credentials.accountSecret).not.toBe(
+      worker.$jazz.localNode.getCurrentAgent().agentSecret,
+    );
 
     // Verify onCreate was called and root was set from worker
-    expect(createdAccount.root.value).toBe("worker-root");
+    expect(created.account.root.value).toBe("worker-root");
 
     // Verify execution order
     expect(executionOrder).toEqual(["migration", "onCreate"]);

package/src/tools/tests/coMap.test.ts

@@ -1098,6 +1098,7 @@ describe("CoMap resolution", async () => {
   });
 
   test("loading a remotely available map with skipRetry set to false", async () => {
+    disableJazzTestSync();
     // Make the retry delay extra long to avoid flakyness in the resolved checks
     cojsonInternals.CO_VALUE_LOADING_CONFIG.RETRY_DELAY = 100_000_000;
 
@@ -1114,13 +1115,6 @@ describe("CoMap resolution", async () => {
 
     const currentAccount = Account.getMe();
 
-    // Disconnect the current account
-    currentAccount.$jazz.localNode.syncManager
-      .getServerPeers(currentAccount.$jazz.raw.id)
-      .forEach((peer) => {
-        peer.gracefulShutdown();
-      });
-
     const group = Group.create();
     group.addMember("everyone", "writer");
 
@@ -1133,6 +1127,10 @@ describe("CoMap resolution", async () => {
       group,
     );
 
+    await setupJazzTestSync({
+      asyncPeers: true,
+    });
+
     const userB = await createJazzTestAccount();
     let resolved = false;
     const promise = Person.load(person.$jazz.id, {

package/src/tools/tests/schema.resolved.test.ts

@@ -246,7 +246,7 @@ describe("Schema.resolved()", () => {
           profile: true,
         });
 
-        const account = await AccountWithProfile.createAs(serverAccount, {
+        const { account } = await AccountWithProfile.createAs(serverAccount, {
           creationProps: { name: "Hermes Puggington" },
           onCreate: async (account) => {
             account.$jazz.set(
@@ -405,7 +405,7 @@ describe("Schema.resolved()", () => {
       test("for Account", async () => {
         const AccountWithProfile = co.account().resolved({ profile: true });
 
-        const account = await AccountWithProfile.createAs(serverAccount, {
+        const { account } = await AccountWithProfile.createAs(serverAccount, {
           creationProps: { name: "Hermes Puggington" },
           onCreate: async (account) => {
             account.$jazz.set(
@@ -561,7 +561,7 @@ describe("Schema.resolved()", () => {
           .list(TestAccount)
           .resolved({ $each: TestAccount.resolveQuery });
 
-        const account = await TestAccount.createAs(serverAccount, {
+        const { account } = await TestAccount.createAs(serverAccount, {
           creationProps: { name: "Hermes Puggington" },
           onCreate: async (account) => {
             account.$jazz.set(

package/tsup.config.ts

@@ -58,6 +58,7 @@ export default defineConfig([
     ...cfg,
     entry: {
       index: "src/inspector/index.tsx",
+      standalone: "src/inspector/standalone.tsx",
     },
     outDir: "dist/inspector",
     esbuildOptions: (options) => {
@@ -132,6 +133,7 @@ export default defineConfig([
       index: "src/react-native-core/index.ts",
       testing: "src/react-native-core/testing.tsx",
       crypto: "src/react-native-core/crypto/index.ts",
+      "crypto/RNCrypto": "src/react-native-core/crypto/RNCrypto.ts",
     },
     outDir: "dist/react-native-core",
   },