jazz-tools 0.18.29 → 0.18.31

package/src/tools/{subscribe → tests}/CoValueCoreSubscription.test.ts

@@ -1,8 +1,9 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-import { Group, co, z } from "../exports.js";
-import { CoValueCoreSubscription } from "./CoValueCoreSubscription.js";
+import { assert, beforeEach, describe, expect, test, vi } from "vitest";
+import { Group, co, exportCoValue, z } from "../exports.js";
+import { CoValueCoreSubscription } from "../subscribe/CoValueCoreSubscription.js";
 import {
   createJazzTestAccount,
+  disableJazzTestSync,
   getPeerConnectedToTestSyncServer,
   setupJazzTestSync,
 } from "../testing.js";
@@ -1100,4 +1101,233 @@ describe("CoValueCoreSubscription", async () => {
       subscription.unsubscribe();
     });
   });
+
+  test("should wait for the full streaming", async () => {
+    disableJazzTestSync();
+
+    const alice = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      update: z.number(),
+    });
+
+    const group = Group.create();
+
+    const person = Person.create(
+      {
+        name: "Bob",
+        update: 1,
+      },
+      group,
+    );
+
+    for (let i = 0; i <= 100; i++) {
+      person.$jazz.applyDiff({
+        name: "1".repeat(1024),
+        update: i,
+      });
+    }
+
+    const bob = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const personContent = await exportCoValue(Person, person.$jazz.id, {
+      loadAs: alice,
+    });
+    assert(personContent);
+
+    const lastPiece = personContent.pop();
+    assert(lastPiece);
+
+    for (const content of personContent) {
+      bob.$jazz.localNode.syncManager.handleNewContent(content, "import");
+    }
+
+    // Simulate the streaming delay on the last piece of the group
+    setTimeout(() => {
+      bob.$jazz.localNode.syncManager.handleNewContent(lastPiece, "import");
+    }, 10);
+
+    // Load the value and expect the migration to run only once
+    // Subscribe to the person
+    let lastResult: any = null;
+    const listener = vi.fn();
+    const subscription = new CoValueCoreSubscription(
+      person.$jazz.localNode,
+      person.$jazz.id,
+      (result) => {
+        lastResult = result;
+        listener(result);
+      },
+    );
+
+    await waitFor(() => expect(listener).toHaveBeenCalled());
+
+    expect(lastResult.core.isCompletelyDownloaded()).toBe(true);
+
+    subscription.unsubscribe();
+  });
+
+  test("should wait for the full streaming of the group", async () => {
+    disableJazzTestSync();
+
+    const alice = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      update: z.number(),
+    });
+
+    const group = Group.create();
+
+    const person = Person.create(
+      {
+        name: "Bob",
+        update: 1,
+      },
+      group,
+    );
+
+    // Make the group to grow big enough to trigger the streaming
+    for (let i = 0; i <= 300; i++) {
+      group.$jazz.raw.rotateReadKey();
+    }
+
+    group.addMember("everyone", "reader");
+
+    const bob = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const personContent = await exportCoValue(Person, person.$jazz.id, {
+      loadAs: alice,
+    });
+    assert(personContent);
+
+    const lastGroupPiece = personContent.findLast(
+      (content) => content.id === group.$jazz.id,
+    );
+    assert(lastGroupPiece);
+
+    for (const content of personContent.filter(
+      (content) => content !== lastGroupPiece,
+    )) {
+      bob.$jazz.localNode.syncManager.handleNewContent(content, "import");
+    }
+
+    // Simulate the streaming delay on the last piece of the group
+    setTimeout(() => {
+      bob.$jazz.localNode.syncManager.handleNewContent(
+        lastGroupPiece,
+        "import",
+      );
+    }, 10);
+
+    // Load the value and expect the migration to run only once
+    // Subscribe to the person
+    let lastResult: any = null;
+    const listener = vi.fn();
+    const subscription = new CoValueCoreSubscription(
+      person.$jazz.localNode,
+      person.$jazz.id,
+      (result) => {
+        lastResult = result;
+        listener(result);
+      },
+    );
+
+    await waitFor(() => expect(listener).toHaveBeenCalled());
+
+    expect(lastResult.core.isCompletelyDownloaded()).toBe(true);
+
+    subscription.unsubscribe();
+  });
+
+  test.skip("should wait for the full streaming of the parent group", async () => {
+    disableJazzTestSync();
+
+    const alice = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      update: z.number(),
+    });
+
+    const group = Group.create();
+    const parentGroup = Group.create();
+
+    const person = Person.create(
+      {
+        name: "Bob",
+        update: 1,
+      },
+      group,
+    );
+
+    // Make the parent group to grow big enough to trigger the streaming
+    for (let i = 0; i <= 300; i++) {
+      parentGroup.$jazz.raw.rotateReadKey();
+    }
+
+    group.addMember(parentGroup);
+    parentGroup.addMember("everyone", "reader");
+
+    const bob = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const personContent = await exportCoValue(Person, person.$jazz.id, {
+      loadAs: alice,
+    });
+    assert(personContent);
+
+    const lastGroupPiece = personContent.findLast(
+      (content) => content.id === parentGroup.$jazz.id,
+    );
+    assert(lastGroupPiece);
+
+    for (const content of personContent.filter(
+      (content) => content !== lastGroupPiece,
+    )) {
+      bob.$jazz.localNode.syncManager.handleNewContent(content, "import");
+    }
+
+    // Simulate the streaming delay on the last piece of the group
+    setTimeout(() => {
+      bob.$jazz.localNode.syncManager.handleNewContent(
+        lastGroupPiece,
+        "import",
+      );
+    }, 10);
+
+    // Load the value and expect the migration to run only once
+    // Subscribe to the person
+    let lastResult: any = null;
+    const listener = vi.fn();
+    const subscription = new CoValueCoreSubscription(
+      person.$jazz.localNode,
+      person.$jazz.id,
+      (result) => {
+        lastResult = result;
+        listener(result);
+      },
+    );
+
+    await waitFor(() => expect(listener).toHaveBeenCalled());
+
+    expect(lastResult.core.isCompletelyDownloaded()).toBe(true);
+
+    subscription.unsubscribe();
+  });
 });

package/src/tools/tests/coFeed.branch.test.ts

@@ -247,6 +247,8 @@ describe("CoFeed Branching", async () => {
         Group.create(me).makePublic("writer"),
       );
 
+      await new Promise((resolve) => setTimeout(resolve, 5));
+
       const branch = await TestStream.load(originalFeed.$jazz.id, {
         unstable_branch: { name: "double-merge-branch" },
       });
@@ -258,7 +260,16 @@ describe("CoFeed Branching", async () => {
       // First merge
       branch.$jazz.unstable_merge();
 
-      expect(originalFeed.perAccount[me.$jazz.id]?.value).toEqual("jam");
+      const feed = await TestStream.load(originalFeed.$jazz.id);
+      assert(feed);
+
+      if (feed.perAccount[me.$jazz.id]?.value !== "jam") {
+        console.log(feed.$jazz.raw.items, feed.perAccount[me.$jazz.id]?.value);
+      }
+
+      expect(feed.perAccount[me.$jazz.id]?.value).toEqual("jam");
+
+      await new Promise((resolve) => setTimeout(resolve, 5));
 
       // Make more changes to the branch
       branch.$jazz.push("cheese");
@@ -267,10 +278,8 @@ describe("CoFeed Branching", async () => {
       branch.$jazz.unstable_merge();
 
       // Verify all changes are applied
-      expect(originalFeed.perAccount[me.$jazz.id]?.value).toEqual("cheese");
-      expect(originalFeed.perSession[me.$jazz.sessionID]?.value).toEqual(
-        "cheese",
-      );
+      expect(feed.perAccount[me.$jazz.id]?.value).toEqual("cheese");
+      expect(feed.perSession[me.$jazz.sessionID]?.value).toEqual("cheese");
     });
 
     test("two users merge different branches with different edits", async () => {

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

@@ -17,9 +17,11 @@ import {
   TypeSym,
   activeAccountContext,
   coValueClassFromCoValueClassOrSchema,
+  exportCoValue,
 } from "../internal.js";
 import {
   createJazzTestAccount,
+  disableJazzTestSync,
   getPeerConnectedToTestSyncServer,
   runWithoutActiveAccount,
   setupJazzTestSync,
@@ -2101,48 +2103,6 @@ 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(),
@@ -2192,6 +2152,143 @@ describe("CoMap migration", () => {
     expect(loaded?.friend?.name).toEqual("Charlie");
     expect(loaded?.friend?.version).toEqual(2);
   });
+
+  test("should wait for the full streaming before running the migration", async () => {
+    disableJazzTestSync();
+    const alice = 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,
+    });
+
+    person.$jazz.owner.addMember("everyone", "reader");
+
+    // Pump the value to reach streaming
+    for (let i = 0; i <= 300; i++) {
+      person.$jazz.raw.assign({
+        name: "1".repeat(1024),
+        update: i,
+      });
+    }
+
+    const bob = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const personContent = await exportCoValue(Person, person.$jazz.id, {
+      loadAs: alice,
+    });
+    assert(personContent);
+
+    migration.mockClear();
+
+    const lastPiece = personContent.pop();
+    assert(lastPiece);
+
+    for (const content of personContent) {
+      bob.$jazz.localNode.syncManager.handleNewContent(content, "storage");
+    }
+
+    // Simulate the streaming delay on the last piece
+    setTimeout(() => {
+      bob.$jazz.localNode.syncManager.handleNewContent(lastPiece, "storage");
+    }, 10);
+
+    // Load the value and expect the migration to run only once
+    const loadedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
+    assert(loadedPerson);
+    expect(migration).toHaveBeenCalledTimes(1);
+    expect(migration).toHaveBeenCalledWith(300);
+  });
+
+  test("should run only when the group is fully loaded", async () => {
+    disableJazzTestSync();
+
+    const alice = 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({
+          groupStreaming:
+            person.$jazz.owner.$jazz.raw.core.verified.isStreaming(),
+        });
+      });
+
+    const group = Group.create();
+
+    const person = Person.create(
+      {
+        name: "Bob",
+        update: 1,
+      },
+      group,
+    );
+
+    for (let i = 0; i <= 300; i++) {
+      group.$jazz.raw.rotateReadKey();
+    }
+
+    group.addMember("everyone", "reader");
+
+    const bob = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const personContent = await exportCoValue(Person, person.$jazz.id, {
+      loadAs: alice,
+    });
+    assert(personContent);
+
+    // Upload and unmount, to force the streaming download
+    migration.mockClear();
+
+    const lastGroupPiece = personContent.findLast(
+      (content) => content.id === group.$jazz.id,
+    );
+    assert(lastGroupPiece);
+
+    for (const content of personContent.filter(
+      (content) => content !== lastGroupPiece,
+    )) {
+      bob.$jazz.localNode.syncManager.handleNewContent(content, "import");
+    }
+
+    // Simulate the streaming delay on the last piece of the group
+    setTimeout(() => {
+      bob.$jazz.localNode.syncManager.handleNewContent(
+        lastGroupPiece,
+        "import",
+      );
+    }, 10);
+
+    // Load the value and expect the migration to run only once
+    const loadedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
+    assert(loadedPerson);
+    expect(migration).toHaveBeenCalledTimes(1);
+    expect(migration).toHaveBeenCalledWith({ groupStreaming: false });
+  });
 });
 
 describe("createdAt & lastUpdatedAt", () => {

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

@@ -37,7 +37,7 @@ describe("co.optional", () => {
     });
   });
 
-  test("can use schem.optional() on all CoValue schemas but co.optional()", () => {
+  test("can use schema.optional() on all CoValue schemas but co.optional()", async () => {
     const Option1 = co.map({ type: z.literal("1") });
     const Option2 = co.map({ type: z.literal("2") });
     const Schema = co.map({
@@ -49,6 +49,7 @@ describe("co.optional", () => {
       map: co.map({ field: z.string() }).optional(),
       list: co.list(z.string()).optional(),
       feed: co.feed(z.string()).optional(),
+      account: co.account().optional(),
       union: co.discriminatedUnion("type", [Option1, Option2]).optional(),
     });
 
@@ -62,6 +63,7 @@ describe("co.optional", () => {
     expect(schema.map).toBeUndefined();
     expect(schema.list).toBeUndefined();
     expect(schema.feed).toBeUndefined();
+    expect(schema.account).toBeUndefined();
     expect(schema.union).toBeUndefined();
 
     schema.$jazz.set(
@@ -91,6 +93,11 @@ describe("co.optional", () => {
     );
     schema.$jazz.set("list", Schema.shape.list.innerType.create([]));
     schema.$jazz.set("feed", Schema.shape.feed.innerType.create([]));
+    const loadedAccount = await co
+      .account()
+      .getMe()
+      .$jazz.ensureLoaded({ resolve: { profile: true, root: true } });
+    schema.$jazz.set("account", loadedAccount);
     schema.$jazz.set("union", Option1.create({ type: "1" }));
 
     expect(schema.plainText?.toString()).toEqual("Hello");
@@ -101,6 +108,7 @@ describe("co.optional", () => {
     expect(schema.map?.field).toEqual("hello");
     expect(schema.list).toEqual([]);
     expect(schema.feed).not.toBeUndefined();
+    expect(schema.account?.profile.name).toEqual("Hermes Puggington");
     expect(schema.union?.type).toEqual("1");
   });