jazz-tools 0.18.16 → 0.18.18

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