jazz-tools 0.10.14 → 0.11.0

package/src/tests/deepLoading.test.ts

@@ -6,6 +6,7 @@ import {
   CoFeed,
   CoList,
   CoMap,
+  Group,
   ID,
   Profile,
   SessionID,
@@ -187,17 +188,15 @@ class CustomAccount extends Account {
     creationProps?: { name: string } | undefined,
   ) {
     if (creationProps) {
+      const profileGroup = Group.create(this);
       this.profile = CustomProfile.create(
         {
           name: creationProps.name,
-          stream: TestStream.create([], { owner: this }),
+          stream: TestStream.create([], this),
         },
-        { owner: this },
-      );
-      this.root = TestMap.create(
-        { list: TestList.create([], { owner: this }) },
-        { owner: this },
+        profileGroup,
       );
+      this.root = TestMap.create({ list: TestList.create([], this) }, this);
     }
 
     const thisLoaded = await this.ensureLoaded({
@@ -312,19 +311,11 @@ test("doesn't break on Map.Record key deletion when the key is referenced in the
 
   class JazzySnapStore extends CoMap.Record(co.ref(JazzProfile)) {}
 
-  const me = await Account.create({
-    creationProps: { name: "Tester McTesterson" },
-    crypto: Crypto,
+  const snapStore = JazzySnapStore.create({
+    profile1: JazzProfile.create({ firstName: "John" }),
+    profile2: JazzProfile.create({ firstName: "John" }),
   });
 
-  const snapStore = JazzySnapStore.create(
-    {
-      profile1: JazzProfile.create({ firstName: "John" }, { owner: me }),
-      profile2: JazzProfile.create({ firstName: "John" }, { owner: me }),
-    },
-    { owner: me },
-  );
-
   const spy = vi.fn();
   const unsub = snapStore.subscribe({ profile1: {}, profile2: {} }, spy);
 

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();