jazz-tools 0.10.15 → 0.11.0

package/src/coValues/group.ts

@@ -1,10 +1,12 @@
 import type {
   AccountRole,
+  AgentID,
   Everyone,
   RawAccountID,
   RawGroup,
   Role,
 } from "cojson";
+import { activeAccountContext } from "../implementation/activeAccountContext.js";
 import type {
   CoValue,
   CoValueClass,
@@ -16,14 +18,15 @@ import type {
 } from "../internal.js";
 import {
   CoValueBase,
-  MembersSym,
   Ref,
+  co,
   ensureCoValueLoaded,
   loadCoValueWithoutMe,
   parseGroupCreateOptions,
   subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
 } from "../internal.js";
+import { RegisteredAccount } from "../types.js";
 import { AccountAndGroupProxyHandler, isControlledAccount } from "./account.js";
 import { type Account } from "./account.js";
 import { type CoMap } from "./coMap.js";
@@ -44,7 +47,6 @@ export class Group extends CoValueBase implements CoValue {
   get _schema(): {
     profile: Schema;
     root: Schema;
-    [MembersSym]: RefEncoded<Account>;
   } {
     return (this.constructor as typeof Group)._schema;
   }
@@ -52,10 +54,6 @@ export class Group extends CoValueBase implements CoValue {
     this._schema = {
       profile: "json" satisfies Schema,
       root: "json" satisfies Schema,
-      [MembersSym]: {
-        ref: () => RegisteredSchemas["Account"],
-        optional: false,
-      } satisfies RefEncoded<Account>,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } as any;
     Object.defineProperty(this.prototype, "_schema", {
@@ -65,7 +63,6 @@ export class Group extends CoValueBase implements CoValue {
 
   declare profile: Profile | null;
   declare root: CoMap | null;
-  declare [MembersSym]: Account | null;
 
   get _refs(): {
     profile: Ref<Profile> | undefined;
@@ -149,34 +146,73 @@ export class Group extends CoValueBase implements CoValue {
     return this._raw.removeMember(member === "everyone" ? member : member._raw);
   }
 
-  get members() {
-    return this._raw
-      .keys()
-      .filter((key) => {
-        return key === "everyone" || key.startsWith("co_");
-      })
-      .map((id) => {
-        const role = this._raw.get(id as Everyone | RawAccountID);
-        const accountID =
-          id === "everyone" ? undefined : (id as unknown as ID<Account>);
-        const ref =
-          accountID &&
-          new Ref<NonNullable<this[MembersSym]>>(
-            accountID,
-            this._loadedAs,
-            this._schema[MembersSym],
-          );
-        const accessRef = () => ref?.accessFrom(this, "members." + id);
-
-        return {
-          id: id as unknown as Everyone | ID<this[MembersSym]>,
+  get members(): Array<{
+    id: ID<RegisteredAccount>;
+    role: AccountRole;
+    ref: Ref<RegisteredAccount>;
+    account: RegisteredAccount;
+  }> {
+    const members = [];
+
+    const BaseAccountSchema =
+      (activeAccountContext.maybeGet()?.constructor as typeof Account) ||
+      RegisteredSchemas["Account"];
+    const refEncodedAccountSchema = {
+      ref: () => BaseAccountSchema,
+      optional: false,
+    } satisfies RefEncoded<RegisteredAccount>;
+
+    for (const accountID of this._raw.getAllMemberKeysSet()) {
+      if (!isAccountID(accountID)) continue;
+
+      const role = this._raw.roleOf(accountID);
+
+      if (
+        role === "admin" ||
+        role === "writer" ||
+        role === "reader" ||
+        role === "writeOnly"
+      ) {
+        const ref = new Ref<RegisteredAccount>(
+          accountID as unknown as ID<RegisteredAccount>,
+          this._loadedAs,
+          refEncodedAccountSchema,
+        );
+        const accessRef = () => ref.accessFrom(this, "members." + accountID);
+
+        if (!ref.syncLoad()) {
+          console.warn("Account not loaded", accountID);
+        }
+
+        members.push({
+          id: accountID as unknown as ID<Account>,
           role,
           ref,
           get account() {
-            return accessRef();
+            // Accounts values are non-nullable because are loaded as dependencies
+            return accessRef() as RegisteredAccount;
           },
-        };
-      });
+        });
+      }
+    }
+
+    return members;
+  }
+
+  getRoleOf(member: Everyone | ID<Account> | "me") {
+    if (member === "me") {
+      return this._raw.roleOf(
+        activeAccountContext.get().id as unknown as RawAccountID,
+      );
+    }
+
+    return this._raw.roleOf(
+      member === "everyone" ? member : (member as unknown as RawAccountID),
+    );
+  }
+
+  getParentGroups(): Array<Group> {
+    return this._raw.getParentGroups().map(({ group }) => Group.fromRaw(group));
   }
 
   extend(
@@ -187,6 +223,11 @@ export class Group extends CoValueBase implements CoValue {
     return this;
   }
 
+  async revokeExtend(parent: Group) {
+    await this._raw.revokeExtend(parent._raw);
+    return this;
+  }
+
   /** @category Subscription & Loading */
   static load<C extends Group, Depth>(
     this: CoValueClass<C>,
@@ -268,3 +309,7 @@ export class Group extends CoValueBase implements CoValue {
 }
 
 RegisteredSchemas["Group"] = Group;
+
+export function isAccountID(id: RawAccountID | AgentID): id is RawAccountID {
+  return id.startsWith("co_");
+}

package/src/coValues/inbox.ts

@@ -332,6 +332,16 @@ export class InboxSender<I extends CoValue, O extends CoValue | undefined> {
       throw new Error("Failed to load the inbox owner profile");
     }
 
+    if (
+      inboxOwnerProfileRaw.group.roleOf(currentAccount._raw.id) !== "reader" &&
+      inboxOwnerProfileRaw.group.roleOf(currentAccount._raw.id) !== "writer" &&
+      inboxOwnerProfileRaw.group.roleOf(currentAccount._raw.id) !== "admin"
+    ) {
+      throw new Error(
+        "Insufficient permissions to access the inbox, make sure its user profile is publicly readable.",
+      );
+    }
+
     const inboxInvite = inboxOwnerProfileRaw.get("inboxInvite");
 
     if (!inboxInvite) {

package/src/coValues/interfaces.ts

@@ -160,7 +160,7 @@ export function loadCoValueWithoutMe<V extends CoValue, Depth>(
   id: ID<CoValue>,
   asOrDepth: Account | AnonymousJazzAgent | (Depth & DepthsIn<V>),
   depth?: Depth & DepthsIn<V>,
-) {
+): Promise<DeeplyLoaded<V, Depth> | undefined> {
   if (isAccountInstance(asOrDepth) || isAnonymousAgentInstance(asOrDepth)) {
     if (!depth) {
       throw new Error(

package/src/coValues/profile.ts

@@ -1,6 +1,8 @@
 import { CoID } from "cojson";
-import { co } from "../internal.js";
-import { CoMap } from "./coMap.js";
+import { CoValueClass, co } from "../internal.js";
+import { Account } from "./account.js";
+import { CoMap, CoMapInit, Simplify } from "./coMap.js";
+import { Group } from "./group.js";
 import { InboxInvite, InboxRoot } from "./inbox.js";
 
 /** @category Identity & Permissions */
@@ -8,4 +10,35 @@ export class Profile extends CoMap {
   name = co.string;
   inbox = co.optional.json<CoID<InboxRoot>>();
   inboxInvite = co.optional.json<InboxInvite>();
+
+  override get _owner(): Group {
+    return super._owner as Group;
+  }
+
+  /**
+   * Creates a new profile with the given initial values and owner.
+   *
+   * The owner (a Group) determines access rights to the Profile.
+   *
+   * @category Creation
+   */
+  static override create<M extends CoMap>(
+    this: CoValueClass<M>,
+    init: Simplify<CoMapInit<M>>,
+    options?:
+      | {
+          owner: Group;
+        }
+      | Group,
+  ) {
+    const owner =
+      options !== undefined && "owner" in options ? options.owner : options;
+
+    // We add some guardrails to ensure that the owner of a profile is a group
+    if ((owner as Group | Account | undefined)?._type === "Account") {
+      throw new Error("Profiles should be owned by a group");
+    }
+
+    return super.create<M>(init, options);
+  }
 }

package/src/implementation/schema.ts

@@ -6,7 +6,6 @@ import {
   CoValueFromRaw,
   ItemsSym,
   JazzToolsSymbol,
-  MembersSym,
   SchemaInit,
   isCoValueClass,
 } from "../internal.js";
@@ -29,7 +28,7 @@ export type CoMarker = { readonly __co: unique symbol };
 export type co<T> = T | (T & CoMarker);
 export type IfCo<C, R> = C extends infer _A | infer B
   ? B extends CoMarker
-    ? R extends JazzToolsSymbol // Exclude symbol properties like co.items or co.members from the refs/init types
+    ? R extends JazzToolsSymbol // Exclude symbol properties like co.items from the refs/init types
       ? never
       : R
     : never
@@ -100,7 +99,6 @@ export const co = {
   },
   ref,
   items: ItemsSym as ItemsSym,
-  members: MembersSym as MembersSym,
   optional,
 };
 

package/src/tests/AuthSecretStorage.test.ts

@@ -1,11 +1,10 @@
 // @vitest-environment happy-dom
 
-import { Account } from "jazz-tools";
-import { ID } from "jazz-tools";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { AuthSecretStorage } from "../auth/AuthSecretStorage";
 import { InMemoryKVStore } from "../auth/InMemoryKVStore.js";
 import KvStoreContext from "../auth/KvStoreContext";
+import { Account, ID } from "../exports";
 
 const kvStore = new InMemoryKVStore();
 KvStoreContext.getInstance().initialize(kvStore);

package/src/tests/PassphraseAuth.test.ts

@@ -2,15 +2,15 @@
 
 import { AgentSecret } from "cojson";
 import { PureJSCrypto } from "cojson/crypto/PureJSCrypto";
+import { assert, beforeEach, describe, expect, it, vi } from "vitest";
+import { PassphraseAuth } from "../auth/PassphraseAuth";
 import {
   Account,
   AuthSecretStorage,
   ID,
   InMemoryKVStore,
   KvStoreContext,
-} from "jazz-tools";
-import { assert, beforeEach, describe, expect, it, vi } from "vitest";
-import { PassphraseAuth } from "../auth/PassphraseAuth";
+} from "../exports";
 import {
   TestJazzContextManager,
   createJazzTestAccount,

package/src/tests/coMap.test.ts

@@ -10,7 +10,7 @@ import {
   createJazzContextFromExistingCredentials,
   isControlledAccount,
 } from "../index.js";
-import { setupTwoNodes, waitFor } from "./utils.js";
+import { setupTwoNodes } from "./utils.js";
 
 const connectedPeers = cojsonInternals.connectedPeers;
 
@@ -119,6 +119,25 @@ describe("Simple CoMap operations", async () => {
     ).toThrow();
   });
 
+  test("testing toJSON on a CoMap with a Date field", () => {
+    const map = TestMap.create(
+      {
+        color: "red",
+        _height: 10,
+        birthday: new Date(),
+      },
+      { owner: me },
+    );
+
+    expect(map.toJSON()).toMatchObject({
+      color: "red",
+      _height: 10,
+      birthday: expect.any(String),
+      _type: "CoMap",
+      id: expect.any(String),
+    });
+  });
+
   test("setting optional date as undefined should not throw", () => {
     const map = TestMap.create(
       {
@@ -336,26 +355,6 @@ describe("Simple CoMap operations", async () => {
     expect(mapWithEnum.child?.value).toEqual(5);
     expect(mapWithEnum.child?.id).toBeDefined();
   });
-
-  class SuperClassMap extends CoMap {
-    name = co.string;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  class SubClassMap extends SuperClassMap {
-    name = co.literal("specificString");
-    value = co.number;
-    extra = co.ref(TestMap);
-  }
-
-  class GenericMapWithLoose<out T extends string = string> extends CoMap {
-    name = co.json<T>();
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const loose: GenericMapWithLoose<string> = {} as GenericMapWithLoose<
-    "a" | "b"
-  >;
 });
 
 describe("CoMap resolution", async () => {

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