jazz-tools 0.10.15 → 0.11.0

package/src/tests/groupsAndAccounts.test.ts

@@ -1,97 +1,84 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
-import { beforeEach, describe, expect, test } from "vitest";
+import { assert, beforeEach, describe, expect, test } from "vitest";
 import { Account, CoMap, Group, Profile, co } from "../exports.js";
-import { createJazzTestAccount } from "../testing.js";
+import { Ref } from "../internal.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 
 beforeEach(async () => {
+  await setupJazzTestSync();
+
   await createJazzTestAccount({
     isCurrentActiveAccount: true,
   });
 });
 
 describe("Custom accounts and groups", async () => {
-  class CustomProfile extends Profile {
-    name = co.string;
-    color = co.string;
-  }
-
-  class CustomAccount extends Account {
-    profile = co.ref(CustomProfile);
-    root = co.ref(CoMap);
-
-    migrate(this: CustomAccount, creationProps?: { name: string }) {
-      if (creationProps) {
-        const profileGroup = Group.create({ owner: this });
-        profileGroup.addMember("everyone", "reader");
-        this.profile = CustomProfile.create(
-          { name: creationProps.name, color: "blue" },
-          { owner: this },
-        );
-      }
+  test("Custom account and group", async () => {
+    class CustomProfile extends Profile {
+      name = co.string;
+      color = co.string;
     }
-  }
-
-  class CustomGroup extends Group {
-    profile = co.null;
-    root = co.null;
-    [co.members] = co.ref(CustomAccount);
 
-    get nMembers() {
-      return this.members.length;
+    class CustomAccount extends Account {
+      profile = co.ref(CustomProfile);
+      root = co.ref(CoMap);
+
+      migrate(this: CustomAccount, creationProps?: { name: string }) {
+        if (creationProps) {
+          const profileGroup = Group.create({ owner: this });
+          profileGroup.addMember("everyone", "reader");
+          this.profile = CustomProfile.create(
+            { name: creationProps.name, color: "blue" },
+            profileGroup,
+          );
+        }
+      }
     }
-  }
 
-  test("Custom account and group", async () => {
-    const me = await CustomAccount.create({
+    const me = await createJazzTestAccount({
       creationProps: { name: "Hermes Puggington" },
-      crypto: Crypto,
+      isCurrentActiveAccount: true,
+      AccountSchema: CustomAccount,
     });
 
     expect(me.profile).toBeDefined();
     expect(me.profile?.name).toBe("Hermes Puggington");
     expect(me.profile?.color).toBe("blue");
 
-    const group = new CustomGroup({ owner: me });
+    const group = Group.create({ owner: me });
     group.addMember("everyone", "reader");
 
-    expect(group.members).toMatchObject([
-      { id: me.id, role: "admin" },
-      { id: "everyone", role: "reader" },
-    ]);
+    expect(group.members).toMatchObject([{ id: me.id, role: "admin" }]);
 
-    expect(group.nMembers).toBe(2);
-
-    await new Promise<void>((resolve) => {
-      group.subscribe({}, (update) => {
-        const meAsMember = update.members.find((member) => {
-          return member.id === me.id && member.account?.profile;
-        });
-        if (meAsMember) {
-          expect(meAsMember.account?.profile?.name).toBe("Hermes Puggington");
-          expect(meAsMember.account?.profile?.color).toBe("blue");
-          resolve();
-        }
-      });
-    });
+    const meAsMember = group.members.find((member) => member.id === me.id);
+    expect((meAsMember?.account as CustomAccount).profile?.name).toBe(
+      "Hermes Puggington",
+    );
+    expect((meAsMember?.account as CustomAccount).profile?.color).toBe("blue");
+  });
 
-    class MyMap extends CoMap {
-      name = co.string;
+  test("Should throw when creating a profile with an account as owner", async () => {
+    class CustomAccount extends Account {
+      migrate(this: CustomAccount, creationProps?: { name: string }) {
+        if (creationProps) {
+          this.profile = Profile.create(
+            { name: creationProps.name },
+            // @ts-expect-error - only groups can own profiles, but we want to also perform a runtime check
+            this,
+          );
+        }
+      }
     }
 
-    const map = MyMap.create({ name: "test" }, { owner: group });
-
-    const meAsCastMember = map._owner
-      .castAs(CustomGroup)
-      .members.find((member) => member.id === me.id);
-    expect(meAsCastMember?.account?.profile?.name).toBe("Hermes Puggington");
-    expect(meAsCastMember?.account?.profile?.color).toBe("blue");
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect((map._owner as any).nMembers).toBeUndefined();
-    expect(map._owner.castAs(CustomGroup).nMembers).toBe(2);
+    await expect(() =>
+      CustomAccount.create({
+        creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
+      }),
+    ).rejects.toThrowError("Profiles should be owned by a group");
   });
 });
 
@@ -173,6 +160,42 @@ describe("Group inheritance", () => {
     expect(mapAsReaderAfterUpdate?.title).toBe("In Grand Child");
   });
 
+  test("Group.getParentGroups should return the parent groups", async () => {
+    const me = await Account.create({
+      creationProps: { name: "Test Owner" },
+      crypto: Crypto,
+    });
+
+    const grandParentGroup = Group.create({ owner: me });
+    const parentGroup = Group.create({ owner: me });
+    const childGroup = Group.create({ owner: me });
+
+    childGroup.extend(parentGroup);
+    parentGroup.extend(grandParentGroup);
+
+    const parentGroups = childGroup.getParentGroups();
+
+    expect(parentGroups).toHaveLength(1);
+    expect(parentGroups).toContainEqual(
+      expect.objectContaining({ id: parentGroup.id }),
+    );
+
+    expect(parentGroups[0]?.getParentGroups()).toContainEqual(
+      expect.objectContaining({ id: grandParentGroup.id }),
+    );
+  });
+
+  test("Account.getParentGroups should return an empty array", async () => {
+    const account = await Account.create({
+      creationProps: { name: "Test Account" },
+      crypto: Crypto,
+    });
+
+    const parentGroups = account.getParentGroups();
+
+    expect(parentGroups).toEqual([]);
+  });
+
   test("waitForSync should resolve when the value is uploaded", async () => {
     const { clientNode, serverNode, clientAccount } = await setupTwoNodes();
 
@@ -192,56 +215,373 @@ describe("Group inheritance", () => {
     const group = Group.create();
     group.addMember("everyone", "reader");
 
-    expect(group.members).toContainEqual({
-      id: "everyone",
-      role: "reader",
-      account: undefined,
-      ref: undefined,
-    });
+    expect(group.getRoleOf("everyone")).toBe("reader");
 
     group.addMember("everyone", "writer");
 
-    expect(group.members).toContainEqual({
-      id: "everyone",
-      role: "writer",
-      account: undefined,
-      ref: undefined,
-    });
+    expect(group.getRoleOf("everyone")).toBe("writer");
 
     // @ts-expect-error - admin is not a valid role for everyone
     expect(() => group.addMember("everyone", "admin")).toThrow();
 
-    expect(group.members).toContainEqual({
-      id: "everyone",
-      role: "writer",
-      account: undefined,
-      ref: undefined,
-    });
+    expect(group.getRoleOf("everyone")).toBe("writer");
 
     // @ts-expect-error - writeOnly is not a valid role for everyone
     expect(() => group.addMember("everyone", "writeOnly")).toThrow();
 
-    expect(group.members).toContainEqual({
-      id: "everyone",
-      role: "writer",
-      account: undefined,
-      ref: undefined,
-    });
+    expect(group.getRoleOf("everyone")).toBe("writer");
   });
 
   test("typescript should show an error when adding a member with a non-account role", async () => {
     const account = await createJazzTestAccount({});
+    await account.waitForAllCoValuesSync();
 
     const group = Group.create();
 
     // @ts-expect-error - Even though readerInvite is a valid role for an account, we don't allow it to not create confusion when using the intellisense
     group.addMember(account, "readerInvite");
 
-    expect(group.members).toContainEqual(
+    expect(group.members).not.toContainEqual(
       expect.objectContaining({
         id: account.id,
         role: "readerInvite",
       }),
     );
+
+    expect(group.getRoleOf(account.id)).toBe("readerInvite");
+  });
+});
+
+describe("Group.getRoleOf", () => {
+  beforeEach(async () => {
+    await createJazzTestAccount({ isCurrentActiveAccount: true });
+  });
+
+  test("returns correct role for admin", async () => {
+    const group = Group.create();
+    const admin = await createJazzTestAccount({});
+    await admin.waitForAllCoValuesSync();
+    group.addMember(admin, "admin");
+    expect(group.getRoleOf(admin.id)).toBe("admin");
+    expect(group.getRoleOf("me")).toBe("admin");
+  });
+
+  test("returns correct role for writer", async () => {
+    const group = Group.create();
+    const writer = await createJazzTestAccount({});
+    await writer.waitForAllCoValuesSync();
+    group.addMember(writer, "writer");
+    expect(group.getRoleOf(writer.id)).toBe("writer");
+  });
+
+  test("returns correct role for reader", async () => {
+    const group = Group.create();
+    const reader = await createJazzTestAccount({});
+    await reader.waitForAllCoValuesSync();
+    group.addMember(reader, "reader");
+    expect(group.getRoleOf(reader.id)).toBe("reader");
+  });
+
+  test("returns correct role for writeOnly", async () => {
+    const group = Group.create();
+    const writeOnly = await createJazzTestAccount({});
+    await writeOnly.waitForAllCoValuesSync();
+    group.addMember(writeOnly, "writeOnly");
+    expect(group.getRoleOf(writeOnly.id)).toBe("writeOnly");
+  });
+
+  test("returns correct role for everyone", () => {
+    const group = Group.create();
+    group.addMember("everyone", "reader");
+    expect(group.getRoleOf("everyone")).toBe("reader");
+  });
+});
+
+describe("Group.getRoleOf with 'me' parameter", () => {
+  beforeEach(async () => {
+    await createJazzTestAccount({ isCurrentActiveAccount: true });
+  });
+
+  test("returns correct role for 'me' when current account is admin", () => {
+    const group = Group.create();
+    expect(group.getRoleOf("me")).toBe("admin");
+  });
+
+  test("returns correct role for 'me' when current account is writer", async () => {
+    const account = await createJazzTestAccount();
+    await account.waitForAllCoValuesSync();
+    const group = Group.create({ owner: account });
+
+    group.addMember(Account.getMe(), "writer");
+
+    expect(group.getRoleOf("me")).toBe("writer");
+  });
+
+  test("returns correct role for 'me' when current account is reader", async () => {
+    const account = await createJazzTestAccount();
+    await account.waitForAllCoValuesSync();
+    const group = Group.create({ owner: account });
+
+    group.addMember(Account.getMe(), "reader");
+
+    expect(group.getRoleOf("me")).toBe("reader");
+  });
+
+  test("returns undefined for 'me' when current account has no role", async () => {
+    const account = await createJazzTestAccount();
+    await account.waitForAllCoValuesSync();
+    const group = Group.create({ owner: account });
+
+    expect(group.getRoleOf("me")).toBeUndefined();
+  });
+});
+
+describe("Account permissions", () => {
+  beforeEach(async () => {
+    await createJazzTestAccount({ isCurrentActiveAccount: true });
+  });
+
+  test("getRoleOf returns admin only for self and me", async () => {
+    const account = await Account.create({
+      creationProps: { name: "Test Account" },
+      crypto: Crypto,
+    });
+
+    // Account should be admin of itself
+    expect(account.getRoleOf(account.id)).toBe("admin");
+
+    // The GlobalMe is not this account
+    expect(account.getRoleOf("me")).toBe(undefined);
+    expect(Account.getMe().getRoleOf("me")).toBe("admin");
+
+    // Other accounts should have no role
+    const otherAccount = await Account.create({
+      creationProps: { name: "Other Account" },
+      crypto: Crypto,
+    });
+    expect(account.getRoleOf(otherAccount.id)).toBeUndefined();
+
+    // Everyone should have no role
+    expect(account.getRoleOf("everyone")).toBeUndefined();
+  });
+
+  test("members array only contains self as admin", async () => {
+    const account = await Account.create({
+      creationProps: { name: "Test Account" },
+      crypto: Crypto,
+    });
+
+    expect(account.members).toEqual([
+      { id: account.id, role: "admin", account: account, ref: expect.any(Ref) },
+    ]);
+  });
+});
+
+describe("Account permissions", () => {
+  test("canRead permissions for different roles", async () => {
+    // Create test accounts
+    const admin = await Account.create({
+      creationProps: { name: "Admin" },
+      crypto: Crypto,
+    });
+
+    const group = Group.create({ owner: admin });
+    const testObject = CoMap.create({}, { owner: group });
+
+    const writer = await Account.createAs(admin, {
+      creationProps: { name: "Writer" },
+    });
+    const reader = await Account.createAs(admin, {
+      creationProps: { name: "Reader" },
+    });
+    const writeOnly = await Account.createAs(admin, {
+      creationProps: { name: "WriteOnly" },
+    });
+
+    // Set up roles
+    group.addMember(writer, "writer");
+    group.addMember(reader, "reader");
+    group.addMember(writeOnly, "writeOnly");
+
+    // Test canRead permissions
+    expect(admin.canRead(testObject)).toBe(true);
+    expect(writer.canRead(testObject)).toBe(true);
+    expect(reader.canRead(testObject)).toBe(true);
+    expect(writeOnly.canRead(testObject)).toBe(true);
+  });
+
+  test("canWrite permissions for different roles", async () => {
+    // Create test accounts
+    const admin = await Account.create({
+      creationProps: { name: "Admin" },
+      crypto: Crypto,
+    });
+
+    const group = Group.create({ owner: admin });
+    const testObject = CoMap.create({}, { owner: group });
+
+    const writer = await Account.createAs(admin, {
+      creationProps: { name: "Writer" },
+    });
+    const reader = await Account.createAs(admin, {
+      creationProps: { name: "Reader" },
+    });
+    const writeOnly = await Account.createAs(admin, {
+      creationProps: { name: "WriteOnly" },
+    });
+
+    // Set up roles
+    group.addMember(writer, "writer");
+    group.addMember(reader, "reader");
+    group.addMember(writeOnly, "writeOnly");
+
+    // Test canWrite permissions
+    expect(admin.canWrite(testObject)).toBe(true);
+    expect(writer.canWrite(testObject)).toBe(true);
+    expect(reader.canWrite(testObject)).toBe(false);
+    expect(writeOnly.canWrite(testObject)).toBe(true);
+  });
+
+  test("canAdmin permissions for different roles", async () => {
+    // Create test accounts
+    const admin = await Account.create({
+      creationProps: { name: "Admin" },
+      crypto: Crypto,
+    });
+
+    const group = Group.create({ owner: admin });
+    const testObject = CoMap.create({}, { owner: group });
+
+    const writer = await Account.createAs(admin, {
+      creationProps: { name: "Writer" },
+    });
+    const reader = await Account.createAs(admin, {
+      creationProps: { name: "Reader" },
+    });
+    const writeOnly = await Account.createAs(admin, {
+      creationProps: { name: "WriteOnly" },
+    });
+
+    // Set up roles
+    group.addMember(writer, "writer");
+    group.addMember(reader, "reader");
+    group.addMember(writeOnly, "writeOnly");
+
+    // Test canAdmin permissions
+    expect(admin.canAdmin(testObject)).toBe(true);
+    expect(writer.canAdmin(testObject)).toBe(false);
+    expect(reader.canAdmin(testObject)).toBe(false);
+    expect(writeOnly.canAdmin(testObject)).toBe(false);
+  });
+
+  test("permissions for non-members", async () => {
+    const admin = await Account.create({
+      creationProps: { name: "Admin" },
+      crypto: Crypto,
+    });
+
+    const group = Group.create({ owner: admin });
+    const testObject = CoMap.create({}, { owner: group });
+
+    const nonMember = await Account.createAs(admin, {
+      creationProps: { name: "NonMember" },
+    });
+
+    // Test permissions for non-member
+    expect(nonMember.canRead(testObject)).toBe(false);
+    expect(nonMember.canWrite(testObject)).toBe(false);
+    expect(nonMember.canAdmin(testObject)).toBe(false);
+  });
+});
+
+describe("Group.members", () => {
+  test("should return the members of the group", async () => {
+    const childGroup = Group.create();
+
+    const bob = await createJazzTestAccount({});
+    await bob.waitForAllCoValuesSync();
+
+    childGroup.addMember(bob, "reader");
+    expect(childGroup.getRoleOf(bob.id)).toBe("reader");
+
+    expect(childGroup.members).toEqual([
+      expect.objectContaining({
+        account: expect.objectContaining({
+          id: Account.getMe().id,
+        }),
+        role: "admin",
+      }),
+      expect.objectContaining({
+        account: expect.objectContaining({
+          id: bob.id,
+        }),
+        role: "reader",
+      }),
+    ]);
+  });
+
+  test("should return the members of the parent group", async () => {
+    const childGroup = Group.create();
+    const parentGroup = Group.create();
+
+    const bob = await createJazzTestAccount({});
+    await bob.waitForAllCoValuesSync();
+
+    parentGroup.addMember(bob, "writer");
+    childGroup.extend(parentGroup, "reader");
+
+    expect(childGroup.getRoleOf(bob.id)).toBe("reader");
+
+    expect(childGroup.members).toEqual([
+      expect.objectContaining({
+        account: expect.objectContaining({
+          id: Account.getMe().id,
+        }),
+        role: "admin",
+      }),
+      expect.objectContaining({
+        account: expect.objectContaining({
+          id: bob.id,
+        }),
+        role: "reader",
+      }),
+    ]);
+  });
+
+  test("should not return everyone", async () => {
+    const childGroup = Group.create();
+
+    childGroup.addMember("everyone", "reader");
+    expect(childGroup.getRoleOf("everyone")).toBe("reader");
+
+    expect(childGroup.members).toEqual([
+      expect.objectContaining({
+        account: expect.objectContaining({
+          id: Account.getMe().id,
+        }),
+        role: "admin",
+      }),
+    ]);
+  });
+
+  test("should not return revoked members", async () => {
+    const childGroup = Group.create();
+
+    const bob = await createJazzTestAccount({});
+    await bob.waitForAllCoValuesSync();
+
+    childGroup.addMember(bob, "reader");
+    await childGroup.removeMember(bob);
+
+    expect(childGroup.getRoleOf(bob.id)).toBeUndefined();
+
+    expect(childGroup.members).toEqual([
+      expect.objectContaining({
+        account: expect.objectContaining({
+          id: Account.getMe().id,
+        }),
+        role: "admin",
+      }),
+    ]);
   });
 });

package/src/tests/inbox.test.ts

@@ -1,7 +1,9 @@
 import { describe, expect, it } from "vitest";
+import { Account } from "../coValues/account";
 import { CoMap } from "../coValues/coMap";
 import { Group } from "../coValues/group";
 import { Inbox, InboxSender } from "../coValues/inbox";
+import { Profile } from "../exports";
 import { co } from "../internal";
 import { setupTwoNodes, waitFor } from "./utils";
 
@@ -10,6 +12,28 @@ class Message extends CoMap {
 }
 
 describe("Inbox", () => {
+  describe("Private profile", () => {
+    it("Should throw if the inbox owner profile is private", async () => {
+      class WorkerAccount extends Account {
+        migrate() {
+          this.profile = Profile.create(
+            { name: "Worker" },
+            Group.create({ owner: this }),
+          );
+        }
+      }
+
+      const { clientAccount: sender, serverAccount: receiver } =
+        await setupTwoNodes({
+          ServerAccountSchema: WorkerAccount,
+        });
+
+      await expect(() => InboxSender.load(receiver.id, sender)).rejects.toThrow(
+        "Insufficient permissions to access the inbox, make sure its user profile is publicly readable.",
+      );
+    });
+  });
+
   it("should create inbox and allow message exchange between accounts", async () => {
     const { clientAccount: sender, serverAccount: receiver } =
       await setupTwoNodes();

package/src/tests/schema.test.ts

@@ -140,6 +140,15 @@ describe("co.json TypeScript validation", () => {
       }>();
   });
 
+  it("should flag types with symbol keys as invalid", async () => {
+    type InvalidType = { [key: symbol]: string };
+
+    class InvalidFunctionMap extends CoMap {
+      // @ts-expect-error Should not be considered valid
+      data = co.json<InvalidType>();
+    }
+  });
+
   it("should apply the same validation to optional json", async () => {
     type ValidType = {
       value: string;
@@ -163,17 +172,48 @@ describe("co.json TypeScript validation", () => {
       }>();
   });
 
+  /* Special case from reported issue:
+   ** See: https://github.com/garden-co/jazz/issues/1496
+   */
+  it("should apply the same validation to optional json [JAZZ-1496]", async () => {
+    interface ValidInterface0 {
+      value: string;
+    }
+    interface ValidInterface1 {
+      value: string | undefined;
+    }
+    interface InterfaceWithOptionalTypes {
+      requiredValue: string;
+      value?: string;
+    }
+
+    class MapWithOptionalJSON extends CoMap {
+      data1 = co.optional.json<ValidInterface0>();
+      data2 = co.optional.json<ValidInterface1>();
+      data3 = co.optional.json<InterfaceWithOptionalTypes>();
+    }
+
+    expectTypeOf(MapWithOptionalJSON.create<MapWithOptionalJSON>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data1?: valueWithCoMarker<ValidInterface0> | null;
+        data2?: valueWithCoMarker<ValidInterface1> | null;
+        data3?: valueWithCoMarker<InterfaceWithOptionalTypes> | null;
+      }>();
+  });
+
   it("should not accept functions", async () => {
     class InvalidFunctionMap extends CoMap {
       // @ts-expect-error Should not be considered valid
       data = co.json<() => void>();
     }
+  });
 
-    expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
-      .parameter(0)
-      .toEqualTypeOf<{
-        data: valueWithCoMarker<() => void>;
-      }>();
+  it("should not accept functions in nested properties", async () => {
+    class InvalidFunctionMap extends CoMap {
+      // @ts-expect-error Should not be considered valid
+      data = co.json<{ func: () => void }>();
+    }
   });
 
   it("should not accept RegExp", async () => {