jazz-tools 0.15.14 → 0.15.16

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

@@ -2103,3 +2103,144 @@ describe("CoMap migration", () => {
     });
   });
 });
+
+describe("Updating a nested reference", () => {
+  test("should assign a resolved optional reference and expect value is not null", async () => {
+    // Define the schema similar to the server-worker-http example
+    const PlaySelection = co.map({
+      value: z.literal(["rock", "paper", "scissors"]),
+      group: Group,
+    });
+
+    const Player = co.map({
+      account: co.account(),
+      playSelection: PlaySelection.optional(),
+    });
+
+    const Game = co.map({
+      player1: Player,
+      player2: Player,
+      outcome: z.literal(["player1", "player2", "draw"]).optional(),
+      player1Score: z.number(),
+      player2Score: z.number(),
+    });
+
+    // Create accounts for the players
+    const player1Account = await createJazzTestAccount({
+      creationProps: { name: "Player 1" },
+    });
+    const player2Account = await createJazzTestAccount({
+      creationProps: { name: "Player 2" },
+    });
+
+    // Create a game
+    const game = Game.create({
+      player1: Player.create({
+        account: player1Account,
+      }),
+      player2: Player.create({
+        account: player2Account,
+      }),
+      player1Score: 0,
+      player2Score: 0,
+    });
+
+    // Create a group for the play selection (similar to the route logic)
+    const group = Group.create({ owner: Account.getMe() });
+    group.addMember(player1Account, "reader");
+
+    // Load the game to verify the assignment worked
+    const loadedGame = await Game.load(game.id, {
+      resolve: {
+        player1: {
+          account: true,
+          playSelection: true,
+        },
+        player2: {
+          account: true,
+          playSelection: true,
+        },
+      },
+    });
+
+    assert(loadedGame);
+
+    // Create a play selection
+    const playSelection = PlaySelection.create({ value: "rock", group }, group);
+
+    // Assign the play selection to player1 (similar to the route logic)
+    loadedGame.player1.playSelection = playSelection;
+
+    // Verify that the playSelection is not null and has the expected value
+    expect(loadedGame.player1.playSelection).not.toBeNull();
+    expect(loadedGame.player1.playSelection).toBeDefined();
+  });
+
+  test("should assign a resolved reference and expect value to update", async () => {
+    // Define the schema similar to the server-worker-http example
+    const PlaySelection = co.map({
+      value: z.literal(["rock", "paper", "scissors"]),
+    });
+
+    const Player = co.map({
+      account: co.account(),
+      playSelection: PlaySelection,
+    });
+
+    const Game = co.map({
+      player1: Player,
+      player2: Player,
+      outcome: z.literal(["player1", "player2", "draw"]).optional(),
+      player1Score: z.number(),
+      player2Score: z.number(),
+    });
+
+    // Create accounts for the players
+    const player1Account = await createJazzTestAccount({
+      creationProps: { name: "Player 1" },
+    });
+    const player2Account = await createJazzTestAccount({
+      creationProps: { name: "Player 2" },
+    });
+
+    // Create a game
+    const game = Game.create({
+      player1: Player.create({
+        account: player1Account,
+        playSelection: PlaySelection.create({ value: "rock" }),
+      }),
+      player2: Player.create({
+        account: player2Account,
+        playSelection: PlaySelection.create({ value: "paper" }),
+      }),
+      player1Score: 0,
+      player2Score: 0,
+    });
+
+    // Load the game to verify the assignment worked
+    const loadedGame = await Game.load(game.id, {
+      resolve: {
+        player1: {
+          account: true,
+          playSelection: true,
+        },
+        player2: {
+          account: true,
+          playSelection: true,
+        },
+      },
+    });
+
+    assert(loadedGame);
+
+    // Create a play selection
+    const playSelection = PlaySelection.create({ value: "scissors" });
+
+    // Assign the play selection to player1 (similar to the route logic)
+    loadedGame.player1.playSelection = playSelection;
+
+    // Verify that the playSelection is not null and has the expected value
+    expect(loadedGame.player1.playSelection.id).toBe(playSelection.id);
+    expect(loadedGame.player1.playSelection.value).toEqual("scissors");
+  });
+});

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.def.shape.comments.create([comment1, comment2], group),
+      },
+      group,
+    );
+
+    const blog = Blog.create(
+      { name: "My Blog", posts: Blog.def.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");
+  });
+});