jazz-tools 0.18.17 → 0.18.19

package/src/react-core/tests/useAccountWithSelector.test.ts

@@ -1,7 +1,7 @@
 // @vitest-environment happy-dom
 
-import { Account, RefsToResolve, co, z } from "jazz-tools";
-import { beforeEach, describe, expect, it } from "vitest";
+import { Account, RefsToResolve, co, z, Group } from "jazz-tools";
+import { assert, beforeEach, describe, expect, it } from "vitest";
 import { useAccountWithSelector, useJazzContextManager } from "../hooks.js";
 import { useIsAuthenticated } from "../index.js";
 import {
@@ -408,4 +408,100 @@ describe("useAccountWithSelector", () => {
 
     expect(result.current.result).toEqual("initial-suffix2");
   });
+
+  it("should work with branches - create branch, edit and merge", async () => {
+    const AccountRoot = co.map({
+      name: z.string(),
+      age: z.number(),
+      email: z.string(),
+    });
+
+    const AccountSchema = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration((account, creationProps) => {
+        if (!account.$jazz.refs.root) {
+          account.$jazz.set("root", {
+            name: "John Doe",
+            age: 30,
+            email: "john@example.com",
+          });
+        }
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema,
+      isCurrentActiveAccount: true,
+    });
+
+    const group = Group.create();
+    group.addMember("everyone", "writer");
+    const { result } = renderHook(
+      () => {
+        const branchAccountRoot = useAccountWithSelector(AccountSchema, {
+          resolve: {
+            root: true,
+          },
+          select: (account) => account?.root,
+          unstable_branch: { name: "feature-branch" },
+        });
+
+        const mainAccountRoot = useAccountWithSelector(AccountSchema, {
+          resolve: {
+            root: true,
+          },
+          select: (account) => account?.root,
+        });
+
+        return {
+          branchAccountRoot,
+          mainAccountRoot,
+        };
+      },
+      {
+        account,
+      },
+    );
+
+    await act(async () => {
+      // Wait for the account to be loaded
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    });
+
+    expect(result.current).not.toBeNull();
+
+    const branchAccountRoot = result.current.branchAccountRoot;
+    const mainAccountRoot = result.current.mainAccountRoot;
+
+    assert(branchAccountRoot);
+    assert(mainAccountRoot);
+
+    act(() => {
+      branchAccountRoot.$jazz.applyDiff({
+        name: "John Smith",
+        age: 31,
+        email: "john.smith@example.com",
+      });
+    });
+
+    // Verify the branch has the changes
+    expect(branchAccountRoot.name).toBe("John Smith");
+    expect(branchAccountRoot.age).toBe(31);
+    expect(branchAccountRoot.email).toBe("john.smith@example.com");
+
+    // Verify the original is unchanged
+    expect(mainAccountRoot.name).toBe("John Doe");
+    expect(mainAccountRoot.age).toBe(30);
+    expect(mainAccountRoot.email).toBe("john@example.com");
+
+    // Merge the branch back
+    branchAccountRoot.$jazz.unstable_merge();
+
+    // Verify the original now has the merged changes
+    expect(mainAccountRoot.name).toBe("John Smith");
+    expect(mainAccountRoot.age).toBe(31);
+    expect(mainAccountRoot.email).toBe("john.smith@example.com");
+  });
 });

package/src/react-core/tests/useSyncConnectionStatus.test.ts

@@ -0,0 +1,48 @@
+// @vitest-environment happy-dom
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useSyncConnectionStatus } from "../hooks";
+import {
+  createJazzTestAccount,
+  setupJazzTestSync,
+  MockConnectionStatus,
+} from "../testing";
+import { act, cleanup, renderHook } from "./testUtils";
+
+describe("useSyncConnectionStatus", () => {
+  beforeEach(async () => {
+    await setupJazzTestSync();
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    cleanup();
+  });
+
+  it("should return true by default in the test environment", () => {
+    const { result } = renderHook(() => useSyncConnectionStatus());
+
+    expect(result.current).toBe(true);
+  });
+
+  it("should handle updates", async () => {
+    const { result } = renderHook(() => useSyncConnectionStatus());
+
+    expect(result.current).toBe(true);
+
+    act(() => {
+      MockConnectionStatus.setIsConnected(false);
+    });
+
+    expect(result.current).toBe(false);
+
+    act(() => {
+      MockConnectionStatus.setIsConnected(true);
+    });
+
+    expect(result.current).toBe(true);
+  });
+});

package/src/react-native-core/hooks.tsx

@@ -15,6 +15,7 @@ export {
   useAccount,
   useCoStateWithSelector,
   useAccountWithSelector,
+  useSyncConnectionStatus,
 } from "jazz-tools/react-core";
 
 export function useAcceptInviteNative<S extends CoValueClassOrSchema>({

package/src/react-native-core/platform.ts

@@ -56,6 +56,8 @@ async function setupPeers(options: BaseReactNativeContextOptions) {
   if (options.sync.when === "never") {
     return {
       toggleNetwork: () => {},
+      addConnectionListener: () => () => {},
+      connected: () => false,
       peersToLoadFrom,
       setNode: () => {},
       crypto,
@@ -96,6 +98,14 @@ async function setupPeers(options: BaseReactNativeContextOptions) {
 
   return {
     toggleNetwork,
+    addConnectionListener(listener: (connected: boolean) => void) {
+      wsPeer.subscribe(listener);
+
+      return () => {
+        wsPeer.unsubscribe(listener);
+      };
+    },
+    connected: () => wsPeer.connected,
     peersToLoadFrom,
     setNode,
     crypto,
@@ -106,8 +116,15 @@ async function setupPeers(options: BaseReactNativeContextOptions) {
 export async function createJazzReactNativeGuestContext(
   options: BaseReactNativeContextOptions,
 ) {
-  const { toggleNetwork, peersToLoadFrom, setNode, crypto, storage } =
-    await setupPeers(options);
+  const {
+    toggleNetwork,
+    peersToLoadFrom,
+    setNode,
+    crypto,
+    storage,
+    addConnectionListener,
+    connected,
+  } = await setupPeers(options);
 
   const context = createAnonymousJazzContext({
     crypto,
@@ -130,6 +147,8 @@ export async function createJazzReactNativeGuestContext(
     logOut: () => {
       return context.logOut();
     },
+    addConnectionListener,
+    connected,
   };
 }
 
@@ -149,8 +168,15 @@ export async function createJazzReactNativeContext<
     | (AccountClass<Account> & CoValueFromRaw<Account>)
     | AnyAccountSchema,
 >(options: ReactNativeContextOptions<S>) {
-  const { toggleNetwork, peersToLoadFrom, setNode, crypto, storage } =
-    await setupPeers(options);
+  const {
+    toggleNetwork,
+    peersToLoadFrom,
+    setNode,
+    crypto,
+    storage,
+    addConnectionListener,
+    connected,
+  } = await setupPeers(options);
 
   let unsubscribeAuthUpdate = () => {};
 
@@ -201,6 +227,8 @@ export async function createJazzReactNativeContext<
       unsubscribeAuthUpdate();
       return context.logOut();
     },
+    addConnectionListener,
+    connected,
   };
 }
 

package/src/svelte/jazz.class.svelte.ts

@@ -205,3 +205,47 @@ export class AccountCoState<
     return this.#isAuthenticated.current;
   }
 }
+
+/**
+ * Class that provides the current connection status to the Jazz sync server.
+ *
+ * @returns `true` when connected to the server, `false` when disconnected
+ *
+ * @remarks
+ * On connection drop, this will return `false` only when Jazz detects the disconnection
+ * after 5 seconds of not receiving a ping from the server.
+ */
+export class SyncConnectionStatus {
+  #ctx = getJazzContext<InstanceOfSchema<AccountClass<Account>>>();
+  #subscribe: () => void;
+  #update = () => {};
+
+  constructor() {
+    this.#subscribe = createSubscriber((update) => {
+      this.#update = update;
+    });
+
+    $effect.pre(() => {
+      const ctx = this.#ctx.current;
+
+      return untrack(() => {
+        if (!ctx) {
+          return;
+        }
+
+        const unsubscribe = ctx.addConnectionListener(() => {
+          this.#update();
+        });
+
+        return () => {
+          unsubscribe();
+        };
+      });
+    });
+  }
+
+  get current() {
+    this.#subscribe();
+    return this.#ctx.current?.connected() ?? false;
+  }
+}

package/src/svelte/testing.ts

@@ -39,4 +39,5 @@ export {
   linkAccounts,
   setActiveAccount,
   setupJazzTestSync,
+  MockConnectionStatus,
 } from "jazz-tools/testing";

package/src/svelte/tests/TestConnectionStatus.svelte

@@ -0,0 +1,8 @@
+<script>
+  import { SyncConnectionStatus } from "../jazz.class.svelte";
+  const connectionStatus = new SyncConnectionStatus();
+</script>
+
+<div>
+  <div data-testid="connected">{connectionStatus.current ? "true" : "false"}</div>
+</div>

package/src/svelte/tests/sync-connection-status.svelte.test.ts

@@ -0,0 +1,61 @@
+// @vitest-environment happy-dom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  createJazzTestAccount,
+  setupJazzTestSync,
+  MockConnectionStatus,
+} from "../testing";
+import { render, screen, waitFor } from "./testUtils";
+import TestConnectionStatus from "./TestConnectionStatus.svelte";
+
+describe("SyncConnectionStatus", () => {
+  beforeEach(async () => {
+    await setupJazzTestSync();
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should return true by default in the test environment", async () => {
+    const { container } = render(TestConnectionStatus, {}, {
+      account: await createJazzTestAccount({
+        isCurrentActiveAccount: true,
+      }),
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("connected").textContent).toBe("true");
+    });
+  });
+
+  it("should handle updates", async () => {
+    const { container } = render(TestConnectionStatus, {}, {
+      account: await createJazzTestAccount({
+        isCurrentActiveAccount: true,
+      }),
+    });
+
+    // Initially should be connected
+    await waitFor(() => {
+      expect(screen.getByTestId("connected").textContent).toBe("true");
+    });
+
+    // Simulate disconnection
+    MockConnectionStatus.setIsConnected(false);
+    
+    await waitFor(() => {
+      expect(screen.getByTestId("connected").textContent).toBe("false");
+    });
+
+    // Simulate reconnection
+    MockConnectionStatus.setIsConnected(true);
+    
+    await waitFor(() => {
+      expect(screen.getByTestId("connected").textContent).toBe("true");
+    });
+  });
+});

package/src/tools/coValues/coMap.ts

@@ -34,6 +34,7 @@ import {
   CoValueBase,
   CoValueJazzApi,
   ItemsSym,
+  NotNull,
   Ref,
   RegisteredSchemas,
   SchemaInit,
@@ -760,11 +761,10 @@ class CoMapJazzApi<M extends CoMap> extends CoValueJazzApi<M> {
         ? Key
         : never]?: RefIfCoValue<M[Key]>;
     } & {
-      [Key in CoKeys<M> as M[Key] extends undefined
-        ? never
-        : M[Key] extends CoValue
-          ? Key
-          : never]: RefIfCoValue<M[Key]>;
+      // Non-loaded CoValue refs (i.e. refs with type CoValue | null) are still required refs
+      [Key in CoKeys<M> as NotNull<M[Key]> extends CoValue
+        ? Key
+        : never]: RefIfCoValue<M[Key]>;
     }
   > {
     return makeRefs<CoKeys<this>>(

package/src/tools/implementation/ContextManager.ts

@@ -26,6 +26,8 @@ type PlatformSpecificAuthContext<Acc extends Account> = {
   node: LocalNode;
   logOut: () => Promise<void>;
   done: () => void;
+  addConnectionListener: (listener: (connected: boolean) => void) => () => void;
+  connected: () => boolean;
 };
 
 type PlatformSpecificGuestContext = {
@@ -33,6 +35,8 @@ type PlatformSpecificGuestContext = {
   node: LocalNode;
   logOut: () => Promise<void>;
   done: () => void;
+  addConnectionListener: (listener: (connected: boolean) => void) => () => void;
+  connected: () => boolean;
 };
 
 type PlatformSpecificContext<Acc extends Account> =
@@ -52,6 +56,8 @@ function getAnonymousFallback() {
     logOut: async () => {},
     isAuthenticated: false,
     authenticate: async () => {},
+    addConnectionListener: () => () => {},
+    connected: () => false,
     register: async () => {
       throw new Error("Not implemented");
     },
@@ -134,6 +140,8 @@ export class JazzContextManager<
       authenticate: this.authenticate,
       register: this.register,
       logOut: this.logOut,
+      addConnectionListener: context.addConnectionListener,
+      connected: context.connected,
     };
 
     if (authProps?.credentials) {

package/src/tools/subscribe/SubscriptionScope.ts

@@ -79,7 +79,11 @@ export class SubscriptionScope<D extends CoValue> {
         // - Run the migration only once
         // - Skip all the updates until the migration is done
         // - Trigger handleUpdate only with the final value
-        if (!this.migrated && value !== "unavailable") {
+        if (
+          !this.migrated &&
+          value !== "unavailable" &&
+          !value.core.verified.isStreaming()
+        ) {
           if (this.migrating) {
             return;
           }

package/src/tools/subscribe/index.ts

@@ -18,7 +18,7 @@ export function getSubscriptionScope<D extends CoValue>(value: D) {
   });
 
   Object.defineProperty(value.$jazz, "_subscriptionScope", {
-    value: subscriptionScope,
+    value: newSubscriptionScope,
     writable: false,
     enumerable: false,
     configurable: false,

package/src/tools/testing.ts

@@ -193,6 +193,23 @@ export async function createJazzTestGuest() {
   };
 }
 
+export class MockConnectionStatus {
+  static connected: boolean = true;
+  static connectionListeners = new Set<(isConnected: boolean) => void>();
+  static setIsConnected(isConnected: boolean) {
+    MockConnectionStatus.connected = isConnected;
+    for (const listener of MockConnectionStatus.connectionListeners) {
+      listener(isConnected);
+    }
+  }
+  static addConnectionListener(listener: (isConnected: boolean) => void) {
+    MockConnectionStatus.connectionListeners.add(listener);
+    return () => {
+      MockConnectionStatus.connectionListeners.delete(listener);
+    };
+  }
+}
+
 export type TestJazzContextManagerProps<Acc extends Account> =
   JazzContextManagerBaseProps<Acc> & {
     defaultProfileName?: string;
@@ -249,6 +266,10 @@ export class TestJazzContextManager<
           await storage.clear();
           node.gracefulShutdown();
         },
+        addConnectionListener: (listener) => {
+          return MockConnectionStatus.addConnectionListener(listener);
+        },
+        connected: () => MockConnectionStatus.connected,
       },
       {
         credentials,
@@ -274,6 +295,10 @@ export class TestJazzContextManager<
       logOut: async () => {
         node.gracefulShutdown();
       },
+      addConnectionListener: (listener) => {
+        return MockConnectionStatus.addConnectionListener(listener);
+      },
+      connected: () => MockConnectionStatus.connected,
     });
 
     return context;
@@ -309,6 +334,10 @@ export class TestJazzContextManager<
       logOut: () => {
         return context.logOut();
       },
+      addConnectionListener: (listener: (isConnected: boolean) => void) => {
+        return MockConnectionStatus.addConnectionListener(listener);
+      },
+      connected: () => MockConnectionStatus.connected,
     };
   }
 }

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

@@ -73,6 +73,8 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
       logOut: async () => {
         await context.logOut();
       },
+      addConnectionListener: () => () => {},
+      connected: () => false,
     };
   }
 }
@@ -80,14 +82,12 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
 describe("ContextManager", () => {
   let manager: TestJazzContextManager<Account>;
   let authSecretStorage: AuthSecretStorage;
-  let storage: StorageAPI;
 
   function getCurrentValue() {
     return manager.getCurrentValue() as JazzAuthContext<Account>;
   }
 
   beforeEach(async () => {
-    storage = await createAsyncStorage({});
     KvStoreContext.getInstance().initialize(new InMemoryKVStore());
     authSecretStorage = new AuthSecretStorage();
     await authSecretStorage.clear();

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

@@ -1150,6 +1150,30 @@ describe("CoMap resolution", async () => {
     });
   });
 
+  test("obtaining coMap refs", async () => {
+    const Dog = co.map({
+      name: z.string().optional(),
+      breed: z.string(),
+      owner: co.plainText(),
+      get parent() {
+        return co.optional(Dog);
+      },
+    });
+
+    const dog = Dog.create({
+      name: "Rex",
+      breed: "Labrador",
+      owner: "John",
+      parent: { name: "Fido", breed: "Labrador", owner: "Jane" },
+    });
+
+    const refs = dog.$jazz.refs;
+
+    expect(Object.keys(refs)).toEqual(["owner", "parent"]);
+    expect(refs.owner.id).toEqual(dog.owner.$jazz.id);
+    expect(refs.parent?.id).toEqual(dog.parent!.$jazz.id);
+  });
+
   test("accessing the value refs", async () => {
     const Dog = co.map({
       name: z.string(),
@@ -1181,9 +1205,9 @@ describe("CoMap resolution", async () => {
 
     assert(loadedPerson);
 
-    expect(loadedPerson.$jazz.refs.dog?.id).toBe(person.dog!.$jazz.id);
+    expect(loadedPerson.$jazz.refs.dog.id).toBe(person.dog.$jazz.id);
 
-    const dog = await loadedPerson.$jazz.refs.dog?.load();
+    const dog = await loadedPerson.$jazz.refs.dog.load();
 
     assert(dog);
 
@@ -2510,6 +2534,48 @@ describe("CoMap migration", () => {
     expect(spy).toHaveBeenCalledTimes(1);
   });
 
+  test("should run only when the value is fully loaded", async () => {
+    await setupJazzTestSync({
+      asyncPeers: true,
+    });
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+
+    const migration = vi.fn();
+    const Person = co
+      .map({
+        name: z.string(),
+        update: z.number(),
+      })
+      .withMigration((person) => {
+        migration(person.update);
+      });
+
+    const person = Person.create({
+      name: "Bob",
+      update: 1,
+    });
+
+    // Pump the value to reach streaming
+    for (let i = 0; i <= 300; i++) {
+      person.$jazz.raw.assign({
+        name: "1".repeat(1024),
+        update: i,
+      });
+    }
+
+    // Upload and unmount, to force the streaming download
+    await person.$jazz.waitForSync();
+    person.$jazz.raw.core.unmount();
+
+    // Load the value and expect the migration to run only once
+    await Person.load(person.$jazz.id);
+    expect(migration).toHaveBeenCalledTimes(1);
+    expect(migration).toHaveBeenCalledWith(300);
+  });
+
   test("should not break recursive schemas", async () => {
     const PersonV1 = co.map({
       name: z.string(),

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

@@ -20,6 +20,7 @@ import {
   setupJazzTestSync,
 } from "../testing.js";
 import { setupAccount, waitFor } from "./utils.js";
+import { getSubscriptionScope } from "../subscribe/index.js";
 
 cojsonInternals.setCoValueLoadingRetryDelay(300);
 
@@ -559,10 +560,7 @@ describe("subscribeToCoValue", () => {
     assert(result);
 
     expect(result[0]?.value).toBe("1");
-
-    // expect(updateFn).toHaveBeenCalledTimes(1);
-    // TODO: Getting an extra update here due to https://github.com/garden-co/jazz/issues/2117
-    expect(updateFn).toHaveBeenCalledTimes(2);
+    expect(updateFn).toHaveBeenCalledTimes(1);
   });
 
   it("should handle undefined values in lists with required refs", async () => {
@@ -1281,3 +1279,43 @@ describe("subscribeToCoValue", () => {
     expect(result.data[chunks]).toBe("new entry");
   });
 });
+
+describe("getSubscriptionScope", () => {
+  const Person = co.map({
+    name: z.string(),
+  });
+  let person: co.output<typeof Person>;
+
+  beforeEach(async () => {
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+
+    person = Person.create({ name: "John" });
+  });
+
+  describe("when the coValue doesn't have a subscription scope", () => {
+    it("creates a new subscription scope", () => {
+      expect(person.$jazz._subscriptionScope).toBeUndefined();
+      const subscriptionScope = getSubscriptionScope(person);
+      expect(subscriptionScope).toBeDefined();
+    });
+
+    it("updates the subscription scope in the coValue", () => {
+      const subscriptionScope = getSubscriptionScope(person);
+      expect(person.$jazz._subscriptionScope).toBeDefined();
+      expect(person.$jazz._subscriptionScope).toBe(subscriptionScope);
+    });
+  });
+
+  describe("when the coValue already has a subscription scope", () => {
+    it("returns that subscription scope", async () => {
+      const loadedPerson = await Person.load(person.$jazz.id);
+      assert(loadedPerson);
+      const subscriptionScope = loadedPerson.$jazz._subscriptionScope;
+      expect(subscriptionScope).toBeDefined();
+      expect(getSubscriptionScope(loadedPerson)).toBe(subscriptionScope);
+    });
+  });
+});