jazz-tools 0.17.14 → 0.18.1

package/src/tools/coValues/group.ts

@@ -6,8 +6,7 @@ import type {
   RawGroup,
   Role,
 } from "cojson";
-import type {
-  CoMap,
+import {
   CoValue,
   CoValueClass,
   ID,
@@ -15,15 +14,15 @@ import type {
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
-  Schema,
   SubscribeListenerOptions,
   SubscribeRestArgs,
+  TypeSym,
 } from "../internal.js";
 import {
   Account,
   AccountAndGroupProxyHandler,
   CoValueBase,
-  Profile,
+  CoValueJazzApi,
   Ref,
   RegisteredSchemas,
   accessChildById,
@@ -37,73 +36,23 @@ import {
   subscribeToExistingCoValue,
 } from "../internal.js";
 
+type GroupMember = {
+  id: string;
+  role: AccountRole;
+  ref: Ref<Account>;
+  account: Account;
+};
+
 /** @category Identity & Permissions */
 export class Group extends CoValueBase implements CoValue {
-  declare id: ID<this>;
-  declare _type: "Group";
-  static {
-    this.prototype._type = "Group";
-  }
-  declare _raw: RawGroup;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static _schema: any;
-  get _schema(): {
-    profile: Schema;
-    root: Schema;
-  } {
-    return (this.constructor as typeof Group)._schema;
-  }
+  declare [TypeSym]: "Group";
   static {
-    this._schema = {
-      profile: "json" satisfies Schema,
-      root: "json" satisfies Schema,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    } as any;
-    Object.defineProperty(this.prototype, "_schema", {
-      get: () => this._schema,
-    });
-  }
-
-  declare profile: Profile | null;
-  declare root: CoMap | null;
-
-  get _refs(): {
-    profile: Ref<Profile> | undefined;
-    root: Ref<CoMap> | undefined;
-  } {
-    const profileID = this._raw.get("profile") as unknown as
-      | ID<NonNullable<this["profile"]>>
-      | undefined;
-    const rootID = this._raw.get("root") as unknown as
-      | ID<NonNullable<this["root"]>>
-      | undefined;
-    return {
-      profile: profileID
-        ? (new Ref(
-            profileID,
-            this._loadedAs,
-            this._schema.profile as RefEncoded<NonNullable<this["profile"]>>,
-            this,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          ) as any as this["profile"] extends Profile
-            ? Ref<this["profile"]>
-            : never)
-        : undefined,
-      root: rootID
-        ? (new Ref(
-            rootID,
-            this._loadedAs,
-            this._schema.root as RefEncoded<NonNullable<this["root"]>>,
-            this,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          ) as any as this["root"] extends CoMap ? Ref<this["root"]> : never)
-        : undefined,
-    };
+    this.prototype[TypeSym] = "Group";
   }
+  declare $jazz: GroupJazzApi<this>;
 
   /** @deprecated Don't use constructor directly, use .create */
-  constructor(options: { fromRaw: RawGroup } | { owner: Account | Group }) {
+  constructor(options: { fromRaw: RawGroup } | { owner: Account }) {
     super();
     let raw: RawGroup;
 
@@ -112,23 +61,27 @@ export class Group extends CoValueBase implements CoValue {
     } else {
       const initOwner = options.owner;
       if (!initOwner) throw new Error("No owner provided");
-      if (initOwner._type === "Account" && isControlledAccount(initOwner)) {
-        const rawOwner = initOwner._raw;
+      if (initOwner[TypeSym] === "Account" && isControlledAccount(initOwner)) {
+        const rawOwner = initOwner.$jazz.raw;
         raw = rawOwner.core.node.createGroup();
       } else {
         throw new Error("Can only construct group as a controlled account");
       }
     }
 
+    const proxy = new Proxy(
+      this,
+      AccountAndGroupProxyHandler as ProxyHandler<this>,
+    );
+
     Object.defineProperties(this, {
-      id: {
-        value: raw.id,
+      $jazz: {
+        value: new GroupJazzApi(proxy, raw),
         enumerable: false,
       },
-      _raw: { value: raw, enumerable: false },
     });
 
-    return new Proxy(this, AccountAndGroupProxyHandler as ProxyHandler<this>);
+    return proxy;
   }
 
   static create<G extends Group>(
@@ -139,7 +92,7 @@ export class Group extends CoValueBase implements CoValue {
   }
 
   myRole(): Role | undefined {
-    return this._raw.myRole();
+    return this.$jazz.raw.myRole();
   }
 
   addMember(member: Everyone, role: "writer" | "reader" | "writeOnly"): void;
@@ -158,12 +111,15 @@ export class Group extends CoValueBase implements CoValue {
     member: Group | Everyone | Account,
     role?: AccountRole | "inherit",
   ) {
-    if (member !== "everyone" && member._type === "Group") {
+    if (member !== "everyone" && member[TypeSym] === "Group") {
       if (role === "writeOnly")
         throw new Error("Cannot add group as member with write-only role");
-      this._raw.extend(member._raw, role);
+      this.$jazz.raw.extend(member.$jazz.raw, role);
     } else if (role !== undefined && role !== "inherit") {
-      this._raw.addMember(member === "everyone" ? member : member._raw, role);
+      this.$jazz.raw.addMember(
+        member === "everyone" ? member : member.$jazz.raw,
+        role,
+      );
     }
   }
 
@@ -174,23 +130,18 @@ export class Group extends CoValueBase implements CoValue {
    */
   removeMember(member: Group): void;
   removeMember(member: Group | Everyone | Account) {
-    if (member !== "everyone" && member._type === "Group") {
-      this._raw.revokeExtend(member._raw);
+    if (member !== "everyone" && member[TypeSym] === "Group") {
+      this.$jazz.raw.revokeExtend(member.$jazz.raw);
     } else {
-      return this._raw.removeMember(
-        member === "everyone" ? member : member._raw,
+      return this.$jazz.raw.removeMember(
+        member === "everyone" ? member : member.$jazz.raw,
       );
     }
   }
 
   private getMembersFromKeys(
     accountIDs: Iterable<RawAccountID | AgentID>,
-  ): Array<{
-    id: string;
-    role: AccountRole;
-    ref: Ref<Account>;
-    account: Account;
-  }> {
+  ): GroupMember[] {
     const members = [];
 
     const refEncodedAccountSchema = {
@@ -201,7 +152,7 @@ export class Group extends CoValueBase implements CoValue {
     for (const accountID of accountIDs) {
       if (!isAccountID(accountID)) continue;
 
-      const role = this._raw.roleOf(accountID);
+      const role = this.$jazz.raw.roleOf(accountID);
 
       if (
         role === "admin" ||
@@ -211,7 +162,7 @@ export class Group extends CoValueBase implements CoValue {
       ) {
         const ref = new Ref<Account>(
           accountID,
-          this._loadedAs,
+          this.$jazz.loadedAs,
           refEncodedAccountSchema,
           this,
         );
@@ -242,8 +193,8 @@ export class Group extends CoValueBase implements CoValue {
    *
    * @returns The members of the group.
    */
-  get members() {
-    return this.getMembersFromKeys(this._raw.getAllMemberKeysSet());
+  get members(): GroupMember[] {
+    return this.getMembersFromKeys(this.$jazz.raw.getAllMemberKeysSet());
   }
 
   /**
@@ -253,20 +204,18 @@ export class Group extends CoValueBase implements CoValue {
    * parent groups, use {@link Group.members|members} instead.
    * @returns The direct members of the group.
    */
-  getDirectMembers() {
-    return this.getMembersFromKeys(this._raw.getMemberKeys());
+  getDirectMembers(): GroupMember[] {
+    return this.getMembersFromKeys(this.$jazz.raw.getMemberKeys());
   }
 
-  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),
-    );
+  getRoleOf(member: Everyone | ID<Account> | "me"): Role | undefined {
+    const accountId =
+      member === "me"
+        ? (activeAccountContext.get().$jazz.id as RawAccountID)
+        : member === "everyone"
+          ? member
+          : (member as RawAccountID);
+    return this.$jazz.raw.roleOf(accountId);
   }
 
   /**
@@ -276,13 +225,15 @@ export class Group extends CoValueBase implements CoValue {
    * @param role - Optional: the role to grant to everyone. Defaults to "reader".
    * @returns The group itself.
    */
-  makePublic(role: "reader" | "writer" = "reader") {
+  makePublic(role: "reader" | "writer" = "reader"): this {
     this.addMember("everyone", role);
     return this;
   }
 
   getParentGroups(): Array<Group> {
-    return this._raw.getParentGroups().map((group) => Group.fromRaw(group));
+    return this.$jazz.raw
+      .getParentGroups()
+      .map((group) => Group.fromRaw(group));
   }
 
   /** @category Identity & Permissions
@@ -295,8 +246,8 @@ export class Group extends CoValueBase implements CoValue {
   extend(
     parent: Group,
     roleMapping?: "reader" | "writer" | "admin" | "inherit",
-  ) {
-    this._raw.extend(parent._raw, roleMapping);
+  ): this {
+    this.$jazz.raw.extend(parent.$jazz.raw, roleMapping);
     return this;
   }
 
@@ -306,8 +257,8 @@ export class Group extends CoValueBase implements CoValue {
    * @param parent The group that will lose access to this group.
    * @returns This group.
    */
-  async revokeExtend(parent: Group) {
-    await this._raw.revokeExtend(parent._raw);
+  async revokeExtend(parent: Group): Promise<this> {
+    await this.$jazz.raw.revokeExtend(parent.$jazz.raw);
     return this;
   }
 
@@ -340,31 +291,55 @@ export class Group extends CoValueBase implements CoValue {
     const { options, listener } = parseSubscribeRestArgs(args);
     return subscribeToCoValueWithoutMe<G, R>(this, id, options, listener);
   }
+}
+
+export class GroupJazzApi<G extends Group> extends CoValueJazzApi<G> {
+  constructor(
+    private group: G,
+    public raw: RawGroup,
+  ) {
+    super(group);
+  }
+
+  /**
+   * The ID of this `Group`
+   * @category Content
+   */
+  get id(): ID<G> {
+    return this.raw.id;
+  }
+
+  /**
+   * Groups have no owner. They can be accessed by everyone.
+   */
+  get owner(): undefined {
+    return undefined;
+  }
 
   /** @category Subscription & Loading */
   ensureLoaded<G extends Group, const R extends RefsToResolve<G>>(
-    this: G,
+    this: GroupJazzApi<G>,
     options?: { resolve?: RefsToResolveStrict<G, R> },
   ): Promise<Resolved<G, R>> {
-    return ensureCoValueLoaded(this, options);
+    return ensureCoValueLoaded(this.group, options);
   }
 
   /** @category Subscription & Loading */
   subscribe<G extends Group, const R extends RefsToResolve<G>>(
-    this: G,
+    this: GroupJazzApi<G>,
     listener: (value: Resolved<G, R>, unsubscribe: () => void) => void,
   ): () => void;
   subscribe<G extends Group, const R extends RefsToResolve<G>>(
-    this: G,
+    this: GroupJazzApi<G>,
     options: { resolve?: RefsToResolveStrict<G, R> },
     listener: (value: Resolved<G, R>, unsubscribe: () => void) => void,
   ): () => void;
   subscribe<G extends Group, const R extends RefsToResolve<G>>(
-    this: G,
+    this: GroupJazzApi<G>,
     ...args: SubscribeRestArgs<G, R>
   ): () => void {
     const { options, listener } = parseSubscribeRestArgs(args);
-    return subscribeToExistingCoValue(this, options, listener);
+    return subscribeToExistingCoValue(this.group, options, listener);
   }
 
   /**
@@ -373,7 +348,7 @@ export class Group extends CoValueBase implements CoValue {
    * @category Subscription & Loading
    */
   waitForSync(options?: { timeout?: number }) {
-    return this._raw.core.waitForSync(options);
+    return this.raw.core.waitForSync(options);
   }
 }
 
@@ -382,3 +357,14 @@ RegisteredSchemas["Group"] = Group;
 export function isAccountID(id: RawAccountID | AgentID): id is RawAccountID {
   return id.startsWith("co_");
 }
+
+export function getCoValueOwner(coValue: CoValue): Group {
+  const group = accessChildById(coValue, coValue.$jazz.raw.group.id, {
+    ref: RegisteredSchemas["Group"],
+    optional: false,
+  });
+  if (!group) {
+    throw new Error("CoValue has no owner");
+  }
+  return group;
+}

package/src/tools/coValues/inbox.ts

@@ -29,11 +29,11 @@ export type InboxRoot = RawCoMap<{
 }>;
 
 export function createInboxRoot(account: Account) {
-  if (!account.isLocalNodeOwner) {
+  if (!account.$jazz.isLocalNodeOwner) {
     throw new Error("Account is not controlled");
   }
 
-  const rawAccount = account._raw;
+  const rawAccount = account.$jazz.raw;
 
   const group = rawAccount.core.node.createGroup();
   const messagesFeed = group.createStream<MessagesStream>();
@@ -66,7 +66,7 @@ async function createInboxMessage<
   I extends CoValue,
   O extends CoValue | undefined,
 >(payload: I, inboxOwner: RawAccount) {
-  const group = payload._raw.group;
+  const group = payload.$jazz.raw.group;
 
   if (group instanceof RawAccount) {
     throw new Error("Inbox messages should be owned by a group");
@@ -75,13 +75,13 @@ async function createInboxMessage<
   group.addMember(inboxOwner, "writer");
 
   const message = group.createMap<InboxMessage<I, O>>({
-    payload: payload.id,
+    payload: payload.$jazz.id,
     result: undefined,
     processed: false,
     error: undefined,
   });
 
-  await payload._raw.core.waitForSync();
+  await payload.$jazz.raw.core.waitForSync();
   await message.core.waitForSync();
 
   return message;
@@ -119,7 +119,7 @@ export class Inbox {
   ) {
     const processed = new Set<`${SessionID}/${number}`>();
     const failed = new Map<`${SessionID}/${number}`, string[]>();
-    const node = this.account._raw.core.node;
+    const node = this.account.$jazz.localNode;
 
     this.processed.subscribe((stream) => {
       for (const items of Object.values(stream.items)) {
@@ -194,7 +194,7 @@ export class Inbox {
                   .getCurrentContent() as RawCoMap;
 
                 if (result) {
-                  inboxMessage.set("result", result.id);
+                  inboxMessage.set("result", result.$jazz.id);
                 }
 
                 inboxMessage.set("processed", true);
@@ -258,7 +258,7 @@ export class Inbox {
       throw new Error("The account has not set up their inbox");
     }
 
-    const node = account._raw.core.node;
+    const node = account.$jazz.localNode;
 
     const root = await node.load(profile.inbox as CoID<InboxRoot>);
 
@@ -332,7 +332,7 @@ export class InboxSender<I extends CoValue, O extends CoValue | undefined> {
   >(inboxOwnerID: ID<Account>, currentAccount?: Account) {
     currentAccount ||= activeAccountContext.get();
 
-    const node = currentAccount._raw.core.node;
+    const node = currentAccount.$jazz.localNode;
 
     const inboxOwnerRaw = await node.load(
       inboxOwnerID as unknown as CoID<RawAccount>,
@@ -349,9 +349,11 @@ export class InboxSender<I extends CoValue, O extends CoValue | undefined> {
     }
 
     if (
-      inboxOwnerProfileRaw.group.roleOf(currentAccount._raw.id) !== "reader" &&
-      inboxOwnerProfileRaw.group.roleOf(currentAccount._raw.id) !== "writer" &&
-      inboxOwnerProfileRaw.group.roleOf(currentAccount._raw.id) !== "admin"
+      inboxOwnerProfileRaw.group.roleOf(currentAccount.$jazz.raw.id) !==
+        "reader" &&
+      inboxOwnerProfileRaw.group.roleOf(currentAccount.$jazz.raw.id) !==
+        "writer" &&
+      inboxOwnerProfileRaw.group.roleOf(currentAccount.$jazz.raw.id) !== "admin"
     ) {
       throw new Error(
         "Insufficient permissions to access the inbox, make sure its user profile is publicly readable.",
@@ -387,11 +389,11 @@ async function acceptInvite(invite: string, account?: Account) {
     throw new Error("Invalid inbox ticket");
   }
 
-  if (!account.isLocalNodeOwner) {
+  if (!account.$jazz.isLocalNodeOwner) {
     throw new Error("Account is not controlled");
   }
 
-  await account._raw.core.node.acceptInvite(id, inviteSecret);
+  await account.$jazz.localNode.acceptInvite(id, inviteSecret);
 
   return id;
 }

package/src/tools/coValues/interfaces.ts

@@ -18,6 +18,7 @@ import {
   Resolved,
   SubscriptionScope,
   type SubscriptionValue,
+  TypeSym,
   activeAccountContext,
   coValueClassFromCoValueClassOrSchema,
   inspect,
@@ -32,26 +33,28 @@ export interface CoValueClass<Value extends CoValue = CoValue> {
 }
 
 export interface CoValueFromRaw<V extends CoValue> {
-  fromRaw(raw: V["_raw"]): V;
+  fromRaw(raw: V["$jazz"]["raw"]): V;
 }
 
 /** @category Abstract interfaces */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export interface CoValue {
-  /** @category Content */
-  readonly id: ID<this>;
   /** @category Type Helpers */
-  _type: string;
-  /** @category Collaboration */
-  _owner: Account | Group;
-  /** @category Internals */
-  _raw: RawCoValue;
-
-  /** @internal */
-  _subscriptionScope?: SubscriptionScope<this>;
+  [TypeSym]: string;
+
+  $jazz: {
+    /** @category Content */
+    readonly id: ID<CoValue>;
+    /** @category Collaboration */
+    owner?: Group;
+    /** @internal */
+    readonly loadedAs: Account | AnonymousJazzAgent;
+    /** @category Internals */
+    raw: RawCoValue;
+    /** @internal */
+    _subscriptionScope?: SubscriptionScope<CoValue>;
+  };
 
-  /** @internal */
-  readonly _loadedAs: Account | AnonymousJazzAgent;
   /** @category Stringifying & Inspection */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   toJSON(key?: string, seenAbove?: ID<CoValue>[]): any[] | object | string;
@@ -62,7 +65,7 @@ export interface CoValue {
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isCoValue(value: any): value is CoValue {
-  return value && value._type !== undefined;
+  return value && value[TypeSym] !== undefined;
 }
 
 export function isCoValueClass<V extends CoValue>(
@@ -149,15 +152,15 @@ export async function ensureCoValueLoaded<
 ): Promise<Resolved<V, R>> {
   const response = await loadCoValue(
     existing.constructor as CoValueClass<V>,
-    existing.id,
+    existing.$jazz.id,
     {
-      loadAs: existing._loadedAs,
+      loadAs: existing.$jazz.loadedAs,
       resolve: options?.resolve,
     },
   );
 
   if (!response) {
-    throw new Error("Failed to deeply load CoValue " + existing.id);
+    throw new Error("Failed to deeply load CoValue " + existing.$jazz.id);
   }
 
   return response;
@@ -255,7 +258,7 @@ export function subscribeToCoValue<
   listener: SubscribeListener<V, R>,
 ): () => void {
   const loadAs = options.loadAs ?? activeAccountContext.get();
-  const node = "node" in loadAs ? loadAs.node : loadAs._raw.core.node;
+  const node = "node" in loadAs ? loadAs.node : loadAs.$jazz.localNode;
 
   const resolve = options.resolve ?? true;
 
@@ -325,9 +328,9 @@ export function subscribeToExistingCoValue<
 ): () => void {
   return subscribeToCoValue(
     existing.constructor as CoValueClass<V>,
-    existing.id,
+    existing.$jazz.id,
     {
-      loadAs: existing._loadedAs,
+      loadAs: existing.$jazz.loadedAs,
       resolve: options?.resolve,
       onUnavailable: options?.onUnavailable,
       onUnauthorized: options?.onUnauthorized,
@@ -341,7 +344,7 @@ export function isAccountInstance(instance: unknown): instance is Account {
     return false;
   }
 
-  return "_type" in instance && instance._type === "Account";
+  return TypeSym in instance && instance[TypeSym] === "Account";
 }
 
 export function isAnonymousAgentInstance(
@@ -351,7 +354,7 @@ export function isAnonymousAgentInstance(
     return false;
   }
 
-  return "_type" in instance && instance._type === "Anonymous";
+  return TypeSym in instance && instance[TypeSym] === "Anonymous";
 }
 
 export function parseCoValueCreateOptions(
@@ -363,15 +366,20 @@ export function parseCoValueCreateOptions(
     | Account
     | Group
     | undefined,
-) {
+): {
+  owner: Group;
+  uniqueness?: CoValueUniqueness;
+} {
   const Group = RegisteredSchemas["Group"];
 
   if (!options) {
     return { owner: Group.create(), uniqueness: undefined };
   }
 
-  if ("_type" in options) {
-    if (options._type === "Account" || options._type === "Group") {
+  if (TypeSym in options) {
+    if (options[TypeSym] === "Account") {
+      return { owner: accountOrGroupToGroup(options), uniqueness: undefined };
+    } else if (options[TypeSym] === "Group") {
       return { owner: options, uniqueness: undefined };
     }
   }
@@ -380,10 +388,20 @@ export function parseCoValueCreateOptions(
     ? { uniqueness: options.unique }
     : undefined;
 
-  return {
-    owner: options.owner ?? Group.create(),
+  const opts = {
+    owner: options.owner
+      ? accountOrGroupToGroup(options.owner)
+      : Group.create(),
     uniqueness,
   };
+  return opts;
+}
+
+export function accountOrGroupToGroup(accountOrGroup: Account | Group): Group {
+  if (accountOrGroup[TypeSym] === "Group") {
+    return accountOrGroup;
+  }
+  return RegisteredSchemas["Group"].fromRaw(accountOrGroup.$jazz.raw);
 }
 
 export function parseGroupCreateOptions(
@@ -398,7 +416,7 @@ export function parseGroupCreateOptions(
     return { owner: activeAccountContext.get() };
   }
 
-  return "_type" in options && isAccountInstance(options)
+  return TypeSym in options && isAccountInstance(options)
     ? { owner: options }
     : { owner: options.owner ?? activeAccountContext.get() };
 }
@@ -460,7 +478,7 @@ export async function exportCoValue<
   },
 ) {
   const loadAs = options.loadAs ?? activeAccountContext.get();
-  const node = "node" in loadAs ? loadAs.node : loadAs._raw.core.node;
+  const node = "node" in loadAs ? loadAs.node : loadAs.$jazz.localNode;
 
   const resolve = options.resolve ?? true;
 
@@ -515,7 +533,7 @@ function loadContentPiecesFromSubscription(
 
   valuesExported.add(subscription.id);
 
-  const core = subscription.getCurrentValue()?._raw
+  const core = subscription.getCurrentValue()?.$jazz.raw
     .core as AvailableCoValueCore;
 
   if (core) {
@@ -563,7 +581,7 @@ export function importContentPieces(
   loadAs?: Account | AnonymousJazzAgent,
 ) {
   const account = loadAs ?? Account.getMe();
-  const node = "node" in account ? account.node : account._raw.core.node;
+  const node = "node" in account ? account.node : account.$jazz.localNode;
 
   for (const piece of contentPieces) {
     node.syncManager.handleNewContent(piece, "import");