jazz-tools 0.10.14 → 0.11.0

package/src/coValues/coRichText.ts

@@ -611,26 +611,51 @@ export function splitNode(
   }
 }
 
+/**
+ * Heading mark for rich text formatting.
+ */
+export class Heading extends Mark {
+  tag = co.literal("heading");
+  level = co.number;
+}
+
+/**
+ * Paragraph mark for rich text formatting.
+ */
+export class Paragraph extends Mark {
+  tag = co.literal("paragraph");
+}
+
+/**
+ * Link mark for rich text formatting.
+ */
+export class Link extends Mark {
+  tag = co.literal("link");
+  url = co.string;
+}
+
+/**
+ * Strong (bold) mark for rich text formatting.
+ */
+export class Strong extends Mark {
+  tag = co.literal("strong");
+}
+
+/**
+ * Emphasis (italic) mark for rich text formatting.
+ */
+export class Em extends Mark {
+  tag = co.literal("em");
+}
+
 /**
  * Collection of predefined mark types for common text formatting.
  * Includes marks for headings, paragraphs, links, and text styling.
  */
 export const Marks = {
-  Heading: class Heading extends Mark {
-    tag = co.literal("heading");
-    level = co.number;
-  },
-  Paragraph: class Paragraph extends Mark {
-    tag = co.literal("paragraph");
-  },
-  Link: class Link extends Mark {
-    tag = co.literal("link");
-    url = co.string;
-  },
-  Strong: class Strong extends Mark {
-    tag = co.literal("strong");
-  },
-  Em: class Italic extends Mark {
-    tag = co.literal("em");
-  },
+  Heading,
+  Paragraph,
+  Link,
+  Strong,
+  Em,
 };

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/ContextManager.ts

@@ -43,7 +43,8 @@ export class JazzContextManager<
   protected context: PlatformSpecificContext<Acc> | undefined;
   protected props: P | undefined;
   protected authSecretStorage = new AuthSecretStorage();
-  protected authenticating = false;
+  protected keepContextOpen = false;
+  protected contextPromise: Promise<void> | undefined;
 
   constructor() {
     KvStoreContext.getInstance().initialize(this.getKvStore());
@@ -54,6 +55,33 @@ export class JazzContextManager<
   }
 
   async createContext(props: P, authProps?: JazzContextManagerAuthProps) {
+    // We need to store the props here to block the double effect execution
+    // on React. Otherwise when calling propsChanged this.props is undefined.
+    this.props = props;
+
+    // Avoid race condition between the previous context and the new one
+    const { promise, resolve } = createResolvablePromise<void>();
+
+    const prevPromise = this.contextPromise;
+    this.contextPromise = promise;
+
+    await prevPromise;
+
+    try {
+      const result = await this.getNewContext(props, authProps);
+      await this.updateContext(props, result, authProps);
+
+      resolve();
+    } catch (error) {
+      resolve();
+      throw error;
+    }
+  }
+
+  async getNewContext(
+    props: P,
+    authProps?: JazzContextManagerAuthProps,
+  ): Promise<PlatformSpecificContext<Acc>> {
     props;
     authProps;
     throw new Error("Not implemented");
@@ -64,9 +92,9 @@ export class JazzContextManager<
     context: PlatformSpecificContext<Acc>,
     authProps?: JazzContextManagerAuthProps,
   ) {
-    // When authenticating we don't want to close the previous context
+    // When keepContextOpen we don't want to close the previous context
     // because we might need to handle the onAnonymousAccountDiscarded callback
-    if (!this.authenticating) {
+    if (!this.keepContextOpen) {
       this.context?.done();
     }
 
@@ -120,6 +148,18 @@ export class JazzContextManager<
     this.context.done();
   };
 
+  shouldMigrateAnonymousAccount = async () => {
+    if (!this.props?.onAnonymousAccountDiscarded) {
+      return false;
+    }
+
+    const prevCredentials = await this.authSecretStorage.get();
+    const wasAnonymous =
+      this.authSecretStorage.getIsAuthenticated(prevCredentials) === false;
+
+    return wasAnonymous;
+  };
+
   /**
    * Authenticates the user with the given credentials
    */
@@ -129,16 +169,15 @@ export class JazzContextManager<
     }
 
     const prevContext = this.context;
-    const prevCredentials = await this.authSecretStorage.get();
-    const wasAnonymous =
-      this.authSecretStorage.getIsAuthenticated(prevCredentials) === false;
+    const migratingAnonymousAccount =
+      await this.shouldMigrateAnonymousAccount();
 
-    this.authenticating = true;
+    this.keepContextOpen = migratingAnonymousAccount;
     await this.createContext(this.props, { credentials }).finally(() => {
-      this.authenticating = false;
+      this.keepContextOpen = false;
     });
 
-    if (wasAnonymous) {
+    if (migratingAnonymousAccount) {
       await this.handleAnonymousAccountMigration(prevContext);
     }
   };
@@ -152,21 +191,20 @@ export class JazzContextManager<
     }
 
     const prevContext = this.context;
-    const prevCredentials = await this.authSecretStorage.get();
-    const wasAnonymous =
-      this.authSecretStorage.getIsAuthenticated(prevCredentials) === false;
+    const migratingAnonymousAccount =
+      await this.shouldMigrateAnonymousAccount();
 
-    this.authenticating = true;
+    this.keepContextOpen = migratingAnonymousAccount;
     await this.createContext(this.props, {
       newAccountProps: {
         secret: accountSecret,
         creationProps,
       },
     }).finally(() => {
-      this.authenticating = false;
+      this.keepContextOpen = false;
     });
 
-    if (wasAnonymous) {
+    if (migratingAnonymousAccount) {
       await this.handleAnonymousAccountMigration(prevContext);
     }
 
@@ -235,3 +273,13 @@ export class JazzContextManager<
     }
   }
 }
+
+function createResolvablePromise<T>() {
+  let resolve!: (value: T) => void;
+
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+
+  return { promise, resolve };
+}

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/testing.ts

@@ -237,12 +237,10 @@ export class TestJazzContextManager<
     return context;
   }
 
-  async createContext(
+  async getNewContext(
     props: TestJazzContextManagerProps<Acc>,
     authProps?: JazzContextManagerAuthProps,
   ) {
-    this.props = props;
-
     if (!syncServer.current) {
       throw new Error(
         "You need to setup a test sync server with setupJazzTestSync to use the Auth functions",
@@ -260,20 +258,16 @@ export class TestJazzContextManager<
       AccountSchema: props.AccountSchema,
     });
 
-    await this.updateContext(
-      props,
-      {
-        me: context.account,
-        node: context.node,
-        done: () => {
-          context.done();
-        },
-        logOut: () => {
-          return context.logOut();
-        },
+    return {
+      me: context.account,
+      node: context.node,
+      done: () => {
+        context.done();
       },
-      authProps,
-    );
+      logOut: () => {
+        return context.logOut();
+      },
+    };
   }
 }
 

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/ContextManager.test.ts

@@ -35,7 +35,7 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
     AccountSchema?: AccountClass<Acc>;
   }
 > {
-  async createContext(
+  async getNewContext(
     props: JazzContextManagerBaseProps<Acc> & {
       defaultProfileName?: string;
       AccountSchema?: AccountClass<Acc>;
@@ -53,20 +53,16 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
       AccountSchema: props.AccountSchema,
     });
 
-    await this.updateContext(
-      props,
-      {
-        me: context.account,
-        node: context.node,
-        done: () => {
-          context.done();
-        },
-        logOut: async () => {
-          await context.logOut();
-        },
+    return {
+      me: context.account,
+      node: context.node,
+      done: () => {
+        context.done();
       },
-      authProps,
-    );
+      logOut: async () => {
+        await context.logOut();
+      },
+    };
   }
 }
 
@@ -127,6 +123,23 @@ describe("ContextManager", () => {
     expect(getCurrentValue().me.id).toBe(credentials.accountID);
   });
 
+  test("handles race conditions on the context creation", async () => {
+    const account = await createJazzTestAccount();
+
+    manager.createContext({});
+
+    const credentials = {
+      accountID: account.id,
+      accountSecret: account._raw.core.node.account.agentSecret,
+      provider: "test",
+    };
+
+    // Authenticate without waiting for the previous context to be created
+    await manager.authenticate(credentials);
+
+    expect(getCurrentValue().me.id).toBe(credentials.accountID);
+  });
+
   test("calls onLogOut callback when logging out", async () => {
     const onLogOut = vi.fn();
     await manager.createContext({ onLogOut });

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,
@@ -302,6 +302,10 @@ describe("PassphraseAuth with TestJazzContextManager", () => {
       // Verify account was created
       expect(accountId).toBeDefined();
 
+      await contextManager
+        .getCurrentValue()
+        ?.node.syncManager.waitForAllCoValuesSync();
+
       // Verify we can log in with the passphrase
       await contextManager.logOut();
       await passphraseAuth.logIn(passphrase);

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 () => {