jazz-tools 0.15.15 → 0.16.0

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

@@ -0,0 +1,526 @@
+import { cojsonInternals } from "cojson";
+import { assert, beforeEach, describe, expect, test } from "vitest";
+import { exportCoValue, importContentPieces } from "../coValues/interfaces.js";
+import { Account, CoPlainText, Group, co, z } from "../exports.js";
+import {
+  createJazzTestAccount,
+  createJazzTestGuest,
+  setupJazzTestSync,
+} from "../testing.js";
+
+cojsonInternals.CO_VALUE_LOADING_CONFIG.RETRY_DELAY = 10;
+
+beforeEach(async () => {
+  await setupJazzTestSync();
+  await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+  });
+});
+
+describe("exportCoValue", () => {
+  test("exports a simple CoMap", async () => {
+    const Person = co.map({
+      name: z.string(),
+      age: z.number(),
+    });
+
+    const group = Group.create();
+    const person = Person.create({ name: "John", age: 30 }, group);
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+
+    const exported = await exportCoValue(Person, person.id, {
+      loadAs: alice,
+    });
+
+    expect(exported).not.toBeNull();
+    expect(exported).toBeInstanceOf(Array);
+    expect(exported!.length).toBeGreaterThan(0);
+
+    // Verify the exported content contains the person data
+    const hasPersonContent = exported!.some((piece) => piece.id === person.id);
+    expect(hasPersonContent).toBe(true);
+  });
+
+  test("exports a CoMap with nested references", async () => {
+    const Address = co.map({
+      street: z.string(),
+      city: z.string(),
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      address: Address,
+    });
+
+    const group = Group.create();
+    const address = Address.create(
+      { street: "123 Main St", city: "New York" },
+      group,
+    );
+    const person = Person.create({ name: "John", address }, group);
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+
+    const exported = await exportCoValue(Person, person.id, {
+      resolve: { address: true },
+      loadAs: alice,
+    });
+
+    expect(exported).not.toBeNull();
+    expect(exported).toBeInstanceOf(Array);
+    expect(exported!.length).toBeGreaterThan(0);
+
+    // Verify both person and address content are exported
+    const personContent = exported!.filter((piece) => piece.id === person.id);
+    const addressContent = exported!.filter((piece) => piece.id === address.id);
+
+    expect(personContent.length).toBeGreaterThan(0);
+    expect(addressContent.length).toBeGreaterThan(0);
+  });
+
+  test("exports a CoList", async () => {
+    const TodoList = co.list(z.string());
+
+    const group = Group.create();
+    const todos = TodoList.create([], group);
+    todos.push("Buy groceries");
+    todos.push("Walk the dog");
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+
+    const exported = await exportCoValue(TodoList, todos.id, {
+      loadAs: alice,
+    });
+
+    expect(exported).not.toBeNull();
+    expect(exported).toBeInstanceOf(Array);
+    expect(exported!.length).toBeGreaterThan(0);
+
+    const hasTodoContent = exported!.some((piece) => piece.id === todos.id);
+    expect(hasTodoContent).toBe(true);
+  });
+
+  test("exports a CoStream", async () => {
+    const ChatStream = co.feed(z.string());
+
+    const group = Group.create();
+    const chat = ChatStream.create([], group);
+    chat.push("Hello");
+    chat.push("World");
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+
+    const exported = await exportCoValue(ChatStream, chat.id, {
+      loadAs: alice,
+    });
+
+    expect(exported).not.toBeNull();
+    expect(exported).toBeInstanceOf(Array);
+    expect(exported!.length).toBeGreaterThan(0);
+
+    const hasChatContent = exported!.some((piece) => piece.id === chat.id);
+    expect(hasChatContent).toBe(true);
+  });
+
+  test("returns null for unauthorized CoValue", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+
+    const group = Group.create();
+    const person = Person.create({ name: "John" }, group);
+    // Don't add any members, so it's private
+
+    const alice = await createJazzTestAccount();
+
+    const exported = await exportCoValue(Person, person.id, {
+      loadAs: alice,
+    });
+
+    expect(exported).toBeNull();
+  });
+
+  test("exports with custom resolve options", async () => {
+    const Address = co.map({
+      street: z.string(),
+      city: z.string(),
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      address: Address,
+    });
+
+    const group = Group.create();
+    const address = Address.create(
+      { street: "123 Main St", city: "New York" },
+      group,
+    );
+    const person = Person.create({ name: "John", address }, group);
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+
+    // Export without resolving nested references
+    const exportedWithoutResolve = await exportCoValue(Person, person.id, {
+      resolve: { address: false },
+      loadAs: alice,
+    });
+
+    // Export with resolving nested references
+    const exportedWithResolve = await exportCoValue(Person, person.id, {
+      resolve: { address: true },
+      loadAs: alice,
+    });
+
+    expect(exportedWithoutResolve).not.toBeNull();
+    expect(exportedWithResolve).not.toBeNull();
+
+    // The version with resolve should have more content pieces
+    expect(exportedWithResolve!.length).toBeGreaterThanOrEqual(
+      exportedWithoutResolve!.length,
+    );
+  });
+
+  test("exports should handle errors on child covalues gracefully", async () => {
+    const Address = co.map({
+      street: co.plainText(),
+      city: co.plainText(),
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      address: Address,
+    });
+
+    const group = Group.create();
+    const address = Address.create(
+      {
+        street: CoPlainText.create("123 Main St"),
+        city: CoPlainText.create("New York"),
+      },
+      group,
+    );
+    const person = Person.create({ name: "John", address }, group);
+
+    // Only add the person to the group, not the address
+    // This makes the address unauthorized for other accounts
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+
+    // Export from alice's perspective with resolve: true
+    // This should attempt to resolve the address but handle the error gracefully
+    const exported = await exportCoValue(Person, person.id, {
+      resolve: { address: { street: true, city: true } },
+      loadAs: alice,
+      bestEffortResolution: true,
+    });
+
+    assert(exported);
+
+    // Verify the person content is exported
+    const personContent = exported.filter((piece) => piece.id === person.id);
+    expect(personContent.length).toBeGreaterThan(0);
+
+    const addressContent = exported.filter((piece) => piece.id === address.id);
+    expect(addressContent.length).toBeGreaterThan(0);
+
+    const streetContent = exported.filter(
+      (piece) => piece.id === address.street.id,
+    );
+    expect(streetContent).toHaveLength(0);
+
+    const cityContent = exported.filter(
+      (piece) => piece.id === address.city.id,
+    );
+    expect(cityContent).toHaveLength(0);
+  });
+});
+
+describe("importContentPieces", () => {
+  test("imports content pieces successfully", async () => {
+    const Person = co.map({
+      name: z.string(),
+      age: z.number(),
+    });
+
+    const group = Group.create();
+    const person = Person.create({ name: "John", age: 30 }, group);
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+    const bob = await createJazzTestAccount();
+
+    bob._raw.core.node.syncManager.getPeers().forEach((peer) => {
+      peer.gracefulShutdown();
+    });
+
+    // Export from alice's perspective
+    const exported = await exportCoValue(Person, person.id, {
+      loadAs: alice,
+    });
+
+    expect(exported).not.toBeNull();
+
+    // Import to bob's node
+    importContentPieces(exported!, bob);
+
+    // Verify bob can now access the person
+    const importedPerson = await Person.load(person.id, { loadAs: bob });
+    expect(importedPerson).not.toBeNull();
+    expect(importedPerson?.name).toBe("John");
+    expect(importedPerson?.age).toBe(30);
+  });
+
+  test("imports content pieces with nested references", async () => {
+    const Address = co.map({
+      street: z.string(),
+      city: z.string(),
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      address: Address,
+    });
+
+    const group = Group.create();
+    const address = Address.create(
+      { street: "123 Main St", city: "New York" },
+      group,
+    );
+    const person = Person.create({ name: "John", address }, group);
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+    const bob = await createJazzTestAccount();
+
+    bob._raw.core.node.syncManager.getPeers().forEach((peer) => {
+      peer.gracefulShutdown();
+    });
+
+    // Export with resolved references
+    const exported = await exportCoValue(Person, person.id, {
+      resolve: { address: true },
+      loadAs: alice,
+    });
+
+    expect(exported).not.toBeNull();
+
+    // Import to bob's node
+    importContentPieces(exported!, bob);
+
+    // Verify bob can access both person and address
+    const importedPerson = await Person.load(person.id, {
+      resolve: { address: true },
+      loadAs: bob,
+    });
+
+    expect(importedPerson).not.toBeNull();
+    expect(importedPerson?.name).toBe("John");
+    expect(importedPerson?.address).not.toBeNull();
+    expect(importedPerson?.address.street).toBe("123 Main St");
+    expect(importedPerson?.address.city).toBe("New York");
+  });
+
+  test("imports content pieces to anonymous agent", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+
+    const group = Group.create();
+    const person = Person.create({ name: "John" }, group);
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+    const { guest } = await createJazzTestGuest();
+
+    guest.node.syncManager.getPeers().forEach((peer) => {
+      peer.gracefulShutdown();
+    });
+
+    // Export from alice's perspective
+    const exported = await exportCoValue(Person, person.id, {
+      loadAs: alice,
+    });
+
+    expect(exported).not.toBeNull();
+
+    // Import to anonymous agent
+    importContentPieces(exported!, guest);
+
+    // Verify anonymous agent can access the person
+    const importedPerson = await Person.load(person.id, { loadAs: guest });
+    expect(importedPerson).not.toBeNull();
+    expect(importedPerson?.name).toBe("John");
+  });
+
+  test("imports content pieces without specifying loadAs (uses current account)", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+
+    const group = Group.create();
+    const person = Person.create({ name: "John" }, group);
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+    const bob = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    bob._raw.core.node.syncManager.getPeers().forEach((peer) => {
+      peer.gracefulShutdown();
+    });
+
+    // Export from alice's perspective
+    const exported = await exportCoValue(Person, person.id, {
+      loadAs: alice,
+    });
+
+    expect(exported).not.toBeNull();
+
+    // Import without specifying loadAs (should use current account)
+    importContentPieces(exported!);
+
+    // Verify bob can access the person
+    const importedPerson = await Person.load(person.id, { loadAs: bob });
+    expect(importedPerson).not.toBeNull();
+    expect(importedPerson?.name).toBe("John");
+  });
+
+  test("handles empty content pieces array", async () => {
+    const alice = await createJazzTestAccount();
+
+    // Should not throw when importing empty array
+    expect(() => {
+      importContentPieces([], alice);
+    }).not.toThrow();
+  });
+
+  test("handles duplicate content pieces", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+
+    const group = Group.create();
+    const person = Person.create({ name: "John" }, group);
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+    const bob = await createJazzTestAccount();
+
+    bob._raw.core.node.syncManager.getPeers().forEach((peer) => {
+      peer.gracefulShutdown();
+    });
+
+    // Export from alice's perspective
+    const exported = await exportCoValue(Person, person.id, {
+      loadAs: alice,
+    });
+
+    expect(exported).not.toBeNull();
+
+    // Import the same content pieces twice
+    importContentPieces(exported!, bob);
+    importContentPieces(exported!, bob);
+
+    // Should still work correctly
+    const importedPerson = await Person.load(person.id, { loadAs: bob });
+    expect(importedPerson).not.toBeNull();
+    expect(importedPerson?.name).toBe("John");
+  });
+
+  test("imports content pieces with complex nested structure", async () => {
+    const Comment = co.map({
+      text: z.string(),
+      author: z.string(),
+    });
+
+    const Post = co.map({
+      title: z.string(),
+      content: z.string(),
+      comments: co.list(Comment),
+    });
+
+    const Blog = co.map({
+      name: z.string(),
+      posts: co.list(Post),
+    });
+
+    const group = Group.create();
+    const comment1 = Comment.create(
+      { text: "Great post!", author: "Alice" },
+      group,
+    );
+    const comment2 = Comment.create({ text: "Thanks!", author: "Bob" }, group);
+
+    const post = Post.create(
+      {
+        title: "My First Post",
+        content: "Hello World",
+        comments: Post.shape.comments.create([comment1, comment2], group),
+      },
+      group,
+    );
+
+    const blog = Blog.create(
+      { name: "My Blog", posts: Blog.shape.posts.create([post], group) },
+      group,
+    );
+
+    group.addMember("everyone", "reader");
+
+    const alice = await createJazzTestAccount();
+    const bob = await createJazzTestAccount();
+
+    bob._raw.core.node.syncManager.getPeers().forEach((peer) => {
+      peer.gracefulShutdown();
+    });
+
+    // Export with all nested references resolved
+    const exported = await exportCoValue(Blog, blog.id, {
+      resolve: {
+        posts: {
+          $each: {
+            comments: true,
+          },
+        },
+      },
+      loadAs: alice,
+    });
+
+    expect(exported).not.toBeNull();
+
+    // Import to bob's node
+    importContentPieces(exported!, bob);
+
+    // Verify bob can access the entire structure
+    const importedBlog = await Blog.load(blog.id, {
+      resolve: {
+        posts: {
+          $each: {
+            comments: true,
+          },
+        },
+      },
+      loadAs: bob,
+    });
+
+    expect(importedBlog).not.toBeNull();
+    expect(importedBlog?.name).toBe("My Blog");
+    expect(importedBlog?.posts.length).toBe(1);
+    expect(importedBlog?.posts[0]?.title).toBe("My First Post");
+    expect(importedBlog?.posts[0]?.content).toBe("Hello World");
+    expect(importedBlog?.posts[0]?.comments.length).toBe(2);
+    expect(importedBlog?.posts[0]?.comments[0]?.text).toBe("Great post!");
+    expect(importedBlog?.posts[0]?.comments[0]?.author).toBe("Alice");
+    expect(importedBlog?.posts[0]?.comments[1]?.text).toBe("Thanks!");
+    expect(importedBlog?.posts[0]?.comments[1]?.author).toBe("Bob");
+  });
+});

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

@@ -1,7 +1,7 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import { CoMap, Group, z } from "../exports.js";
-import { Loaded, Ref, co, zodSchemaToCoSchema } from "../internal.js";
+import { Loaded, Ref, co } from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { setupTwoNodes, waitFor } from "./utils.js";
 
@@ -22,15 +22,16 @@ describe("Custom accounts and groups", async () => {
       color: z.string(),
     });
 
+    const Root = co.map({});
     const CustomAccount = co
       .account({
         profile: CustomProfile,
-        root: co.map({}),
+        root: Root,
       })
       .withMigration((account, creationProps?: { name: string }) => {
         // making sure that the inferred type of account.root & account.profile considers the root/profile not being loaded
         type R = typeof account.root;
-        const _r: R = {} as Loaded<typeof CustomAccount.def.shape.root> | null;
+        const _r: R = {} as Loaded<typeof Root> | null;
         type P = typeof account.profile;
         const _p: P = {} as Loaded<typeof CustomProfile> | null;
         if (creationProps) {
@@ -47,7 +48,7 @@ describe("Custom accounts and groups", async () => {
     const me = await createJazzTestAccount({
       creationProps: { name: "Hermes Puggington" },
       isCurrentActiveAccount: true,
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: CustomAccount,
     });
 
     expect(me.profile).toBeDefined();

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

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 import { Group, Inbox, InboxSender, z } from "../exports";
-import { Loaded, anySchemaToCoSchema, co } from "../internal";
+import { Loaded, co, coValueClassFromCoValueClassOrSchema } from "../internal";
 import { setupTwoNodes, waitFor } from "./utils";
 
 const Message = co.map({
@@ -18,7 +18,8 @@ describe("Inbox", () => {
 
       const { clientAccount: sender, serverAccount: receiver } =
         await setupTwoNodes({
-          ServerAccountSchema: anySchemaToCoSchema(WorkerAccount),
+          ServerAccountSchema:
+            coValueClassFromCoValueClassOrSchema(WorkerAccount),
         });
 
       await expect(() => InboxSender.load(receiver.id, sender)).rejects.toThrow(

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

@@ -69,33 +69,6 @@ test("load a missing optional value (co.optional)", async () => {
   expect(john.dog).toBeUndefined();
 });
 
-test("load a missing optional value (z.optional)", async () => {
-  const Dog = co.map({
-    name: z.string(),
-  });
-
-  const Person = co.map({
-    name: z.string(),
-    dog: z.optional(Dog),
-  });
-
-  const group = Group.create();
-  const map = Person.create({ name: "John" }, group);
-  group.addMember("everyone", "reader");
-
-  const alice = await createJazzTestAccount();
-
-  const john = await Person.load(map.id, {
-    loadAs: alice,
-    resolve: { dog: true },
-  });
-
-  assert(john);
-
-  expect(john.name).toBe("John");
-  expect(john.dog).toBeUndefined();
-});
-
 test("load a missing optional value (Schema.optional)", async () => {
   const Dog = co.map({
     name: z.string(),
@@ -214,13 +187,14 @@ test("returns null if the value is unavailable after retries", async () => {
 test("load a large coValue", async () => {
   const syncServer = await setupJazzTestSync({ asyncPeers: true });
 
+  const Data = co.list(z.string());
   const LargeDataset = co.map({
     metadata: z.object({
       name: z.string(),
       description: z.string(),
       createdAt: z.number(),
     }),
-    data: co.list(z.string()),
+    data: Data,
   });
 
   const group = Group.create(syncServer);
@@ -232,7 +206,7 @@ test("load a large coValue", async () => {
           "A dataset with many entries for testing large coValue loading",
         createdAt: Date.now(),
       },
-      data: LargeDataset.def.shape.data.create([], group),
+      data: Data.create([], group),
     },
     group,
   );