jazz-tools 0.18.17 → 0.18.18

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/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/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

@@ -2510,6 +2510,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

@@ -559,10 +559,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 () => {

package/src/tools/types.ts

@@ -26,6 +26,8 @@ export type JazzAuthContext<Acc extends Account> = {
   logOut: () => Promise<void>;
   done: () => void;
   isAuthenticated?: boolean;
+  addConnectionListener: (listener: (connected: boolean) => void) => () => void;
+  connected: () => boolean;
 };
 
 export type JazzGuestContext = {
@@ -36,6 +38,8 @@ export type JazzGuestContext = {
   logOut: () => void;
   done: () => void;
   isAuthenticated?: boolean;
+  addConnectionListener: (listener: (connected: boolean) => void) => () => void;
+  connected: () => boolean;
 };
 
 export type JazzContextType<Acc extends Account> =