jazz-tools 0.18.28 → 0.18.30

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");
   });
 

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

@@ -481,6 +481,9 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
+    const manager = await co.account().createAs(admin, {
+      creationProps: { name: "Manager" },
+    });
     const writer = await co.account().createAs(admin, {
       creationProps: { name: "Writer" },
     });
@@ -492,11 +495,13 @@ describe("Account permissions", () => {
     });
 
     // Set up roles
+    group.addMember(manager, "manager");
     group.addMember(writer, "writer");
     group.addMember(reader, "reader");
     group.addMember(writeOnly, "writeOnly");
 
     // Test canRead permissions
+    expect(manager.canRead(testObject)).toBe(true);
     expect(admin.canRead(testObject)).toBe(true);
     expect(writer.canRead(testObject)).toBe(true);
     expect(reader.canRead(testObject)).toBe(true);
@@ -513,6 +518,9 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
+    const manager = await co.account().createAs(admin, {
+      creationProps: { name: "Manager" },
+    });
     const writer = await co.account().createAs(admin, {
       creationProps: { name: "Writer" },
     });
@@ -524,11 +532,13 @@ describe("Account permissions", () => {
     });
 
     // Set up roles
+    group.addMember(manager, "manager");
     group.addMember(writer, "writer");
     group.addMember(reader, "reader");
     group.addMember(writeOnly, "writeOnly");
 
     // Test canWrite permissions
+    expect(manager.canWrite(testObject)).toBe(true);
     expect(admin.canWrite(testObject)).toBe(true);
     expect(writer.canWrite(testObject)).toBe(true);
     expect(reader.canWrite(testObject)).toBe(false);
@@ -538,13 +548,17 @@ describe("Account permissions", () => {
   test("canAdmin permissions for different roles", async () => {
     // Create test accounts
     const admin = await co.account().create({
-      creationProps: { name: "Admin" },
+      creationProps: { name: "Super Admin" },
       crypto: Crypto,
     });
 
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
+    const manager = await co.account().createAs(admin, {
+      creationProps: { name: "Admin" },
+    });
+
     const writer = await co.account().createAs(admin, {
       creationProps: { name: "Writer" },
     });
@@ -556,17 +570,57 @@ describe("Account permissions", () => {
     });
 
     // Set up roles
+    group.addMember(manager, "manager");
     group.addMember(writer, "writer");
     group.addMember(reader, "reader");
     group.addMember(writeOnly, "writeOnly");
 
     // Test canAdmin permissions
     expect(admin.canAdmin(testObject)).toBe(true);
+    expect(manager.canAdmin(testObject)).toBe(false);
     expect(writer.canAdmin(testObject)).toBe(false);
     expect(reader.canAdmin(testObject)).toBe(false);
     expect(writeOnly.canAdmin(testObject)).toBe(false);
   });
 
+  test("canManage permissions for different roles", async () => {
+    // Create test accounts
+    const admin = await co.account().create({
+      creationProps: { name: "Super Admin" },
+      crypto: Crypto,
+    });
+
+    const group = Group.create({ owner: admin });
+    const testObject = CoMap.create({}, { owner: group });
+
+    const manager = await co.account().createAs(admin, {
+      creationProps: { name: "Admin" },
+    });
+
+    const writer = await co.account().createAs(admin, {
+      creationProps: { name: "Writer" },
+    });
+    const reader = await co.account().createAs(admin, {
+      creationProps: { name: "Reader" },
+    });
+    const writeOnly = await co.account().createAs(admin, {
+      creationProps: { name: "WriteOnly" },
+    });
+
+    // Set up roles
+    group.addMember(manager, "manager");
+    group.addMember(writer, "writer");
+    group.addMember(reader, "reader");
+    group.addMember(writeOnly, "writeOnly");
+
+    // Test canManage permissions
+    expect(admin.canManage(testObject)).toBe(true);
+    expect(manager.canManage(testObject)).toBe(true);
+    expect(writer.canManage(testObject)).toBe(false);
+    expect(reader.canManage(testObject)).toBe(false);
+    expect(writeOnly.canManage(testObject)).toBe(false);
+  });
+
   test("permissions for non-members", async () => {
     const admin = await co.account().create({
       creationProps: { name: "Admin" },
@@ -584,6 +638,7 @@ describe("Account permissions", () => {
     expect(nonMember.canRead(testObject)).toBe(false);
     expect(nonMember.canWrite(testObject)).toBe(false);
     expect(nonMember.canAdmin(testObject)).toBe(false);
+    expect(nonMember.canManage(testObject)).toBe(false);
   });
 
   describe("permissions over Groups and Accounts", () => {
@@ -810,6 +865,106 @@ describe("Account permissions", () => {
         expect(account.canAdmin(group)).toBe(false);
       });
     });
+
+    describe("manage", () => {
+      test("can manage Account if it's itself", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        expect(account.canManage(account)).toBe(true);
+      });
+
+      test("cannot manage other accounts", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        expect(account.canManage(otherAccount)).toBe(false);
+      });
+
+      test("can manage Group if it's an manage for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "manager");
+
+        expect(account.canManage(group)).toBe(true);
+      });
+
+      test("cannot manage Group if it's a writer for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "writer");
+
+        expect(account.canManage(group)).toBe(false);
+      });
+
+      test("cannot manage Group if it has writeOnly permissions for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "writeOnly");
+
+        expect(account.canManage(group)).toBe(false);
+      });
+
+      test("cannot manage Group if it's a reader for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "reader");
+
+        expect(account.canManage(group)).toBe(false);
+      });
+
+      test("cannot manage Group if it has no permissions for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        expect(account.canManage(group)).toBe(false);
+      });
+    });
   });
 });
 

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

@@ -1,9 +1,10 @@
 import { waitFor } from "@testing-library/dom";
 import { cojsonInternals, emptyKnownState } from "cojson";
 import { assert, beforeEach, expect, test } from "vitest";
-import { Account, Group, co, z } from "../exports.js";
+import { Account, Group, co, exportCoValue, z } from "../exports.js";
 import {
   createJazzTestAccount,
+  disableJazzTestSync,
   getPeerConnectedToTestSyncServer,
   setupJazzTestSync,
 } from "../testing.js";
@@ -270,3 +271,199 @@ test("load a large coValue", async () => {
     largeMap.data.$jazz.raw.core.knownState(),
   );
 });
+
+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
+  const loadedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
+  expect(loadedPerson).not.toBeNull();
+  assert(loadedPerson);
+
+  expect(loadedPerson.$jazz.owner.$jazz.raw.core.verified.isStreaming()).toBe(
+    false,
+  );
+});
+
+test.skip("should wait for the full streaming of the parent groups", async () => {
+  disableJazzTestSync();
+
+  const alice = await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+    creationProps: { name: "Hermes Puggington" },
+  });
+
+  const Person = co.map({
+    name: z.string(),
+    update: z.number(),
+  });
+
+  const parentGroup = Group.create();
+  const group = 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 lastParentGroupPiece = personContent.findLast(
+    (content) => content.id === parentGroup.$jazz.id,
+  );
+  assert(lastParentGroupPiece);
+
+  for (const content of personContent.filter(
+    (content) => content !== lastParentGroupPiece,
+  )) {
+    bob.$jazz.localNode.syncManager.handleNewContent(content, "import");
+  }
+
+  // Simulate the streaming delay on the last piece of the parent group
+  setTimeout(() => {
+    bob.$jazz.localNode.syncManager.handleNewContent(
+      lastParentGroupPiece,
+      "import",
+    );
+  }, 10);
+
+  // Load the value and expect the migration to run only once
+  const loadedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
+  expect(loadedPerson).not.toBeNull();
+  assert(loadedPerson);
+
+  expect(loadedPerson.$jazz.owner.$jazz.raw.core.verified.isStreaming()).toBe(
+    false,
+  );
+});
+
+test("should correctly reject the load if after the group streaming the account has no access", 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,
+  );
+
+  group.addMember("everyone", "reader");
+
+  for (let i = 0; i <= 150; i++) {
+    group.$jazz.raw.rotateReadKey();
+  }
+
+  group.removeMember("everyone");
+
+  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
+  const loadedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
+  expect(loadedPerson).toBeNull();
+});

package/src/tools/tests/zod.test-d.ts

@@ -10,7 +10,6 @@ describe("CoValue and Zod schema compatibility", () => {
 
     const Person = co.map({
       // @ts-expect-error: cannot use z.record with a CoValue schema
-      // (z.record is not exported by jazz-tools)
       pets: z.record(z.string(), Dog),
     });
   });
@@ -68,7 +67,6 @@ describe("CoValue and Zod schema compatibility", () => {
 
     const Person = co.map({
       // @ts-expect-error: cannot use z.intersection with a CoValue schema
-      // (z.intersection is not exported by jazz-tools)
       pets: z.intersection(Dog, Cat),
     });
   });

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

@@ -369,6 +369,18 @@ describe("co.map and Zod schema compatibility", () => {
       expect(map.person).toEqual({ name: "John" });
     });
 
+    it("should handle record fields", async () => {
+      const schema = co.map({
+        record: z.record(z.string(), z.string()),
+      });
+      const account = await createJazzTestAccount();
+      const map = schema.create(
+        { record: { key1: "value1", key2: "value2" } },
+        account,
+      );
+      expect(map.record).toEqual({ key1: "value1", key2: "value2" });
+    });
+
     it("should handle tuple fields", async () => {
       const schema = co.map({
         tuple: z.tuple([z.string(), z.number(), z.boolean()]),
@@ -402,46 +414,37 @@ describe("co.map and Zod schema compatibility", () => {
       expect(map2.value).toBe(42);
     });
 
-    // it("should handle discriminated unions of primitives", async () => {
-    //   const schema = co.map({
-    //     result: z.discriminatedUnion("status", [
-    //       z.object({ status: z.literal("success"), data: z.string() }),
-    //       z.object({ status: z.literal("failed"), error: z.string() }),
-    //     ]),
-    //   });
-    //   const account = await createJazzTestAccount();
-    //   const successMap = schema.create(
-    //     { result: { status: "success", data: "data" } },
-    //     account,
-    //   );
-    //   const failedMap = schema.create(
-    //     { result: { status: "failed", error: "error" } },
-    //     account,
-    //   );
-    //   expect(successMap.result).toEqual({ status: "success", data: "data" });
-    //   expect(failedMap.result).toEqual({ status: "failed", error: "error" });
-    // });
-
-    // it("should handle intersections", async () => {
-    //   const schema = co.map({
-    //     value: z.intersection(
-    //       z.union([z.number(), z.string()]),
-    //       z.union([z.number(), z.boolean()])
-    //     ),
-    //   });
-    //   const account = await createJazzTestAccount();
-    //   const map = schema.create({ value: 42 }, account);
-    //   expect(map.value).toBe(42);
-    // });
-
-    // it("should handle record types", async () => {
-    //   const schema = co.map({
-    //     cache: z.record(z.string(), z.string()),
-    //   });
-    //   const account = await createJazzTestAccount();
-    //   const map = schema.create({ cache: { key1: "value1", key2: "value2" } }, account);
-    //   expect(map.cache).toEqual({ key1: "value1", key2: "value2" });
-    // });
+    it("should handle discriminated unions of primitives", async () => {
+      const schema = co.map({
+        result: z.discriminatedUnion("status", [
+          z.object({ status: z.literal("success"), data: z.string() }),
+          z.object({ status: z.literal("failed"), error: z.string() }),
+        ]),
+      });
+      const account = await createJazzTestAccount();
+      const successMap = schema.create(
+        { result: { status: "success", data: "data" } },
+        account,
+      );
+      const failedMap = schema.create(
+        { result: { status: "failed", error: "error" } },
+        account,
+      );
+      expect(successMap.result).toEqual({ status: "success", data: "data" });
+      expect(failedMap.result).toEqual({ status: "failed", error: "error" });
+    });
+
+    it("should handle intersections", async () => {
+      const schema = co.map({
+        value: z.intersection(
+          z.union([z.number(), z.string()]),
+          z.union([z.number(), z.boolean()]),
+        ),
+      });
+      const account = await createJazzTestAccount();
+      const map = schema.create({ value: 42 }, account);
+      expect(map.value).toBe(42);
+    });
 
     it("should handle refined types", async () => {
       const schema = co.map({