jazz-tools 0.13.16 → 0.13.18

package/src/coValues/coMap.ts

@@ -29,6 +29,8 @@ import {
   ItemsSym,
   Ref,
   SchemaInit,
+  accessChildById,
+  accessChildByKey,
   ensureCoValueLoaded,
   inspect,
   isRefEncoded,
@@ -38,7 +40,6 @@ import {
   parseSubscribeRestArgs,
   subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
-  subscriptionsScopes,
 } from "../internal.js";
 import { RegisteredAccount } from "../types.js";
 import { type Account } from "./account.js";
@@ -137,20 +138,20 @@ export class CoMap extends CoValueBase implements CoValue {
     [Key in CoKeys<this>]: IfCo<this[Key], RefIfCoValue<this[Key]>>;
   } {
     return makeRefs<CoKeys<this>>(
+      this,
       (key) => this._raw.get(key as string) as unknown as ID<CoValue>,
       () => {
         const keys = this._raw.keys().filter((key) => {
-          const schema =
-            this._schema[key as keyof typeof this._schema] ||
-            (this._schema[ItemsSym] as Schema | undefined);
-          return schema && schema !== "json" && isRefEncoded(schema);
+          const descriptor = this.getDescriptor(key as string);
+          return (
+            descriptor && descriptor !== "json" && isRefEncoded(descriptor)
+          );
         }) as CoKeys<this>[];
 
         return keys;
       },
       this._loadedAs,
-      (key) =>
-        (this._schema[key] || this._schema[ItemsSym]) as RefEncoded<CoValue>,
+      (key) => this.getDescriptor(key as string) as RefEncoded<CoValue>,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) as any;
   }
@@ -175,21 +176,22 @@ export class CoMap extends CoValueBase implements CoValue {
             ? rawEdit.value === null || rawEdit.value === undefined
               ? rawEdit.value
               : descriptor.encoded.decode(rawEdit.value)
-            : new Ref(
-                rawEdit.value as ID<CoValue>,
-                target._loadedAs,
-                descriptor,
-              ).accessFrom(target, "_edits." + key + ".value"),
+            : accessChildById(target, rawEdit.value as string, descriptor),
       ref:
         descriptor !== "json" && isRefEncoded(descriptor)
-          ? new Ref(rawEdit.value as ID<CoValue>, target._loadedAs, descriptor)
+          ? new Ref(
+              rawEdit.value as ID<CoValue>,
+              target._loadedAs,
+              descriptor,
+              target,
+            )
           : undefined,
       by:
         rawEdit.by &&
-        new Ref<Account>(rawEdit.by as ID<Account>, target._loadedAs, {
+        accessChildById(target, rawEdit.by, {
           ref: RegisteredSchemas["Account"],
           optional: false,
-        }).accessFrom(target, "_edits." + key + ".by"),
+        }),
       madeAt: rawEdit.at,
       key,
     };
@@ -205,9 +207,9 @@ export class CoMap extends CoValueBase implements CoValue {
           const rawEdit = map._raw.lastEditAt(key as string);
           if (!rawEdit) return undefined;
 
-          const descriptor = map._schema[
-            key as keyof typeof map._schema
-          ] as Schema;
+          const descriptor = map.getDescriptor(key as string);
+
+          if (!descriptor) return undefined;
 
           return {
             ...map.getEditFromRaw(map, rawEdit, descriptor, key as string),
@@ -300,6 +302,7 @@ export class CoMap extends CoValueBase implements CoValue {
       },
       _raw: { value: raw, enumerable: false },
     });
+
     return instance;
   }
 
@@ -316,8 +319,7 @@ export class CoMap extends CoValueBase implements CoValue {
 
     for (const key of this._raw.keys()) {
       const tKey = key as CoKeys<this>;
-      const descriptor = (this._schema[tKey] ||
-        this._schema[ItemsSym]) as Schema;
+      const descriptor = this.getDescriptor(tKey);
 
       if (!descriptor) {
         continue;
@@ -379,8 +381,7 @@ export class CoMap extends CoValueBase implements CoValue {
       for (const key of Object.keys(init) as (keyof Fields)[]) {
         const initValue = init[key as keyof typeof init];
 
-        const descriptor = (this._schema[key as keyof typeof this._schema] ||
-          this._schema[ItemsSym]) as Schema;
+        const descriptor = this.getDescriptor(key as string);
 
         if (!descriptor) {
           continue;
@@ -403,6 +404,10 @@ export class CoMap extends CoValueBase implements CoValue {
     return rawOwner.createMap(rawInit, null, "private", uniqueness);
   }
 
+  getDescriptor(key: string) {
+    return this._schema?.[key] || this._schema?.[ItemsSym];
+  }
+
   /**
    * Declare a Record-like CoMap schema, by extending `CoMap.Record(...)` and passing the value schema using `co`. Keys are always `string`.
    *
@@ -528,7 +533,7 @@ export class CoMap extends CoValueBase implements CoValue {
       uniqueness: unique,
     };
     const crypto =
-      as._type === "Anonymous" ? as.node.crypto : as._raw.core.crypto;
+      as._type === "Anonymous" ? as.node.crypto : as._raw.core.node.crypto;
     return cojsonInternals.idforHeader(header, crypto) as ID<M>;
   }
 
@@ -576,25 +581,24 @@ export class CoMap extends CoValueBase implements CoValue {
     for (const key in newValues) {
       if (Object.prototype.hasOwnProperty.call(newValues, key)) {
         const tKey = key as keyof typeof newValues & keyof this;
-        const descriptor = (this._schema[tKey as string] ||
-          this._schema[ItemsSym]) as Schema;
-
-        if (tKey in this._schema) {
-          const newValue = newValues[tKey];
-          const currentValue = (this as unknown as N)[tKey];
-
-          if (descriptor === "json" || "encoded" in descriptor) {
-            if (currentValue !== newValue) {
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              (this as any)[tKey] = newValue;
-            }
-          } else if (isRefEncoded(descriptor)) {
-            const currentId = (currentValue as CoValue | undefined)?.id;
-            const newId = (newValue as CoValue | undefined)?.id;
-            if (currentId !== newId) {
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              (this as any)[tKey] = newValue;
-            }
+        const descriptor = this.getDescriptor(key);
+
+        if (!descriptor) continue;
+
+        const newValue = newValues[tKey];
+        const currentValue = (this as unknown as N)[tKey];
+
+        if (descriptor === "json" || "encoded" in descriptor) {
+          if (currentValue !== newValue) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (this as any)[tKey] = newValue;
+          }
+        } else if (isRefEncoded(descriptor)) {
+          const currentId = (currentValue as CoValue | undefined)?.id;
+          const newId = (newValue as CoValue | undefined)?.id;
+          if (currentId !== newId) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (this as any)[tKey] = newValue;
           }
         }
       }
@@ -664,33 +668,27 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
     } else if (key in target) {
       return Reflect.get(target, key, receiver);
     } else {
-      const schema = target._schema;
-
-      if (!schema) {
+      if (typeof key !== "string") {
         return undefined;
       }
 
-      const descriptor = (schema[key as keyof CoMap["_schema"]] ||
-        schema[ItemsSym]) as Schema;
-      if (descriptor && typeof key === "string") {
-        const raw = target._raw.get(key);
+      const descriptor = target.getDescriptor(key as string);
 
-        if (descriptor === "json") {
-          return raw;
-        } else if ("encoded" in descriptor) {
-          return raw === undefined ? undefined : descriptor.encoded.decode(raw);
-        } else if (isRefEncoded(descriptor)) {
-          return raw === undefined
-            ? undefined
-            : new Ref(
-                raw as unknown as ID<CoValue>,
-                target._loadedAs,
-                descriptor,
-              ).accessFrom(receiver, key);
-        }
-      } else {
+      if (!descriptor) {
         return undefined;
       }
+
+      const raw = target._raw.get(key);
+
+      if (descriptor === "json") {
+        return raw;
+      } else if ("encoded" in descriptor) {
+        return raw === undefined ? undefined : descriptor.encoded.decode(raw);
+      } else if (isRefEncoded(descriptor)) {
+        return raw === undefined
+          ? undefined
+          : accessChildByKey(target, raw as string, key);
+      }
     }
   },
   set(target, key, value, receiver) {
@@ -705,9 +703,11 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
       return true;
     }
 
-    const descriptor = (target._schema[key as keyof CoMap["_schema"]] ||
-      target._schema[ItemsSym]) as Schema;
-    if (descriptor && typeof key === "string") {
+    const descriptor = target.getDescriptor(key as string);
+
+    if (!descriptor) return false;
+
+    if (typeof key === "string") {
       if (descriptor === "json") {
         target._raw.set(key, value);
       } else if ("encoded" in descriptor) {
@@ -721,9 +721,6 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
           }
         } else if (value?.id) {
           target._raw.set(key, value.id);
-          subscriptionsScopes
-            .get(target)
-            ?.onRefAccessedOrSet(target.id, value.id);
         } else {
           throw new Error(
             `Cannot set reference ${key} to a non-CoValue. Got ${value}`,
@@ -751,11 +748,7 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
   },
   ownKeys(target) {
     const keys = Reflect.ownKeys(target).filter((k) => k !== ItemsSym);
-    // for (const key of Reflect.ownKeys(target._schema)) {
-    //     if (key !== ItemsSym && !keys.includes(key)) {
-    //         keys.push(key);
-    //     }
-    // }
+
     for (const key of target._raw.keys()) {
       if (!keys.includes(key)) {
         keys.push(key);
@@ -768,8 +761,8 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
     if (key in target) {
       return Reflect.getOwnPropertyDescriptor(target, key);
     } else {
-      const descriptor = (target._schema[key as keyof CoMap["_schema"]] ||
-        target._schema[ItemsSym]) as Schema;
+      const descriptor = target.getDescriptor(key as string);
+
       if (descriptor || key in target._raw.latest) {
         return {
           enumerable: true,
@@ -780,8 +773,7 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
     }
   },
   has(target, key) {
-    const descriptor = (target._schema?.[key as keyof CoMap["_schema"]] ||
-      target._schema?.[ItemsSym]) as Schema;
+    const descriptor = target.getDescriptor(key as string);
 
     if (target._raw && typeof key === "string" && descriptor) {
       return target._raw.get(key) !== undefined;
@@ -790,8 +782,8 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
     }
   },
   deleteProperty(target, key) {
-    const descriptor = (target._schema[key as keyof CoMap["_schema"]] ||
-      target._schema[ItemsSym]) as Schema;
+    const descriptor = target.getDescriptor(key as string);
+
     if (typeof key === "string" && descriptor) {
       target._raw.delete(key);
       return true;

package/src/coValues/coPlainText.ts

@@ -1,11 +1,12 @@
 import {
+  ControlledAccount,
   type OpID,
   RawAccount,
   type RawCoPlainText,
   stringifyOpID,
 } from "cojson";
 import { calcPatch } from "fast-myers-diff";
-import type {
+import {
   AnonymousJazzAgent,
   CoValue,
   CoValueClass,
@@ -21,8 +22,10 @@ import {
   subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
 } from "../internal.js";
+import { coValuesCache } from "../lib/cache.js";
 import { Account } from "./account.js";
 import { Group } from "./group.js";
+import { RegisteredSchemas } from "./registeredSchemas.js";
 
 export type TextPos = OpID;
 
@@ -38,7 +41,15 @@ export class CoPlainText extends String implements CoValue {
   }
 
   get _loadedAs() {
-    return Account.fromNode(this._raw.core.node);
+    const agent = this._raw.core.node.getCurrentAgent();
+
+    if (agent instanceof ControlledAccount) {
+      return coValuesCache.get(agent.account, () =>
+        RegisteredSchemas["Account"].fromRaw(agent.account),
+      );
+    }
+
+    return new AnonymousJazzAgent(this._raw.core.node);
   }
 
   constructor(

package/src/coValues/deepLoading.ts

@@ -1,283 +1,10 @@
-import { JsonValue, RawCoList, SessionID } from "cojson";
-import { ItemsSym, type Ref, RefEncoded, UnCo } from "../internal.js";
+import { SessionID } from "cojson";
+import { ItemsSym, UnCo } from "../internal.js";
 import { type Account } from "./account.js";
-import { type CoFeed, CoFeedEntry } from "./coFeed.js";
-import { type CoList } from "./coList.js";
-import { type CoKeys, type CoMap } from "./coMap.js";
+import { CoFeedEntry } from "./coFeed.js";
+import { type CoKeys } from "./coMap.js";
 import { type CoValue, type ID } from "./interfaces.js";
 
-function hasRefValue(value: CoValue, key: string | number) {
-  return Boolean(
-    (
-      value as unknown as {
-        _refs: { [key: string]: Ref<CoValue> | undefined };
-      }
-    )._refs?.[key],
-  );
-}
-
-function hasReadAccess(value: CoValue, key: string | number) {
-  return Boolean(
-    (
-      value as unknown as {
-        _refs: { [key: string]: Ref<CoValue> | undefined };
-      }
-    )._refs?.[key]?.hasReadAccess(),
-  );
-}
-
-function isOptionalField(value: CoValue, key: string): boolean {
-  return (
-    ((value as CoMap)._schema[key] as RefEncoded<CoValue>)?.optional ?? false
-  );
-}
-
-type FulfillsDepthResult =
-  | {
-      status: "fulfilled" | "unfulfilled";
-    }
-  | {
-      status: "unauthorized";
-      path: string[];
-      id: JsonValue;
-    };
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function fulfillsDepth(depth: any, value: CoValue): FulfillsDepthResult {
-  if (depth === true || depth === undefined) {
-    return {
-      status: "fulfilled",
-    };
-  }
-
-  if (
-    value._type === "CoMap" ||
-    value._type === "Group" ||
-    value._type === "Account"
-  ) {
-    const map = value as CoMap;
-
-    if ("$each" in depth) {
-      const result: FulfillsDepthResult = { status: "fulfilled" };
-
-      for (const [key, item] of Object.entries(value)) {
-        const rawValue = map._raw.get(key);
-
-        if (rawValue !== undefined && rawValue !== null) {
-          if (!item) {
-            if (hasReadAccess(map, key)) {
-              result.status = "unfulfilled";
-              continue;
-            } else {
-              return {
-                status: "unauthorized",
-                path: [key],
-                id: rawValue,
-              };
-            }
-          }
-
-          const innerResult = fulfillsDepth(depth.$each, item);
-
-          if (innerResult.status === "unfulfilled") {
-            result.status = "unfulfilled";
-          } else if (
-            innerResult.status === "unauthorized" &&
-            !isOptionalField(value, ItemsSym)
-          ) {
-            innerResult.path.unshift(key);
-
-            return innerResult; // If any item is unauthorized, the whole thing is unauthorized
-          }
-        } else if (!isOptionalField(value, ItemsSym)) {
-          return {
-            status: "unfulfilled",
-          };
-        }
-      }
-
-      return result;
-    } else {
-      const result: FulfillsDepthResult = { status: "fulfilled" };
-
-      for (const key of Object.keys(depth)) {
-        const rawValue = map._raw.get(key);
-
-        if (rawValue === undefined || rawValue === null) {
-          if (!map._schema?.[key]) {
-            // Field not defined in schema
-            if (map._schema?.[ItemsSym]) {
-              // CoMap.Record
-              if (isOptionalField(map, ItemsSym)) {
-                continue;
-              } else {
-                // All fields are required, so the returned type is not optional and we must comply
-                throw new Error(
-                  `The ref ${key} requested on ${map.constructor.name} is missing`,
-                );
-              }
-            } else {
-              // Field not defined in CoMap schema
-              throw new Error(
-                `The ref ${key} requested on ${map.constructor.name} is not defined in the schema`,
-              );
-            }
-          } else if (isOptionalField(map, key)) {
-            continue;
-          } else {
-            // Field is required but has never been set
-            throw new Error(
-              `The ref ${key} on ${map.constructor.name} is required but missing`,
-            );
-          }
-        } else {
-          const item = (value as Record<string, any>)[key];
-
-          if (!item) {
-            if (hasReadAccess(map, key)) {
-              result.status = "unfulfilled";
-              continue;
-            } else {
-              return {
-                status: "unauthorized",
-                path: [key],
-                id: rawValue,
-              };
-            }
-          }
-
-          const innerResult = fulfillsDepth(depth[key], item);
-
-          if (innerResult.status === "unfulfilled") {
-            result.status = "unfulfilled";
-          } else if (
-            innerResult.status === "unauthorized" &&
-            !isOptionalField(value, key)
-          ) {
-            innerResult.path.unshift(key);
-
-            return innerResult; // If any item is unauthorized, the whole thing is unauthorized
-          }
-        }
-      }
-
-      return result;
-    }
-  } else if (value._type === "CoList") {
-    if ("$each" in depth) {
-      const result: FulfillsDepthResult = { status: "fulfilled" };
-      const list = value as CoList;
-
-      for (const [key, item] of (value as CoList).entries()) {
-        const rawValue = list._raw.get(key);
-
-        if (!rawValue) {
-          if (isOptionalField(value, ItemsSym)) {
-            continue;
-          }
-
-          // Throw an error and mark this as unavailable
-          throw new Error(
-            `The ref ${key} on ${list.constructor.name} is required but missing`,
-          );
-        }
-
-        if (hasRefValue(value, key)) {
-          if (!item) {
-            if (hasReadAccess(value, key)) {
-              result.status = "unfulfilled";
-              continue;
-            } else {
-              return {
-                status: "unauthorized",
-                path: [key.toString()],
-                id: (value._raw as RawCoList).get(key) ?? "undefined",
-              };
-            }
-          }
-
-          const innerResult = fulfillsDepth(depth.$each, item);
-
-          if (innerResult.status === "unfulfilled") {
-            result.status = "unfulfilled";
-          } else if (
-            innerResult.status === "unauthorized" &&
-            !isOptionalField(value, ItemsSym)
-          ) {
-            innerResult.path.unshift(key.toString());
-
-            return innerResult; // If any item is unauthorized, the whole thing is unauthorized
-          }
-        } else if (!isOptionalField(value, ItemsSym)) {
-          return {
-            status: "unfulfilled",
-          };
-        }
-      }
-
-      return result;
-    }
-
-    return {
-      status: "fulfilled",
-    };
-  } else if (value._type === "CoStream") {
-    if ("$each" in depth) {
-      const result: FulfillsDepthResult = { status: "fulfilled" };
-
-      for (const item of Object.values((value as CoFeed).perSession)) {
-        if (item.ref) {
-          if (!item.value) {
-            if (item.ref.hasReadAccess()) {
-              result.status = "unfulfilled";
-              continue;
-            } else {
-              return {
-                status: "unauthorized",
-                path: [item.ref.id],
-                id: item.ref.id,
-              };
-            }
-          }
-
-          const innerResult = fulfillsDepth(depth.$each, item.value);
-
-          if (innerResult.status === "unfulfilled") {
-            result.status = "unfulfilled";
-          } else if (
-            innerResult.status === "unauthorized" &&
-            !isOptionalField(value, ItemsSym)
-          ) {
-            innerResult.path.unshift(item.ref.id);
-
-            return innerResult; // If any item is unauthorized, the whole thing is unauthorized
-          }
-        } else if (!isOptionalField(value, ItemsSym)) {
-          return {
-            status: "unfulfilled",
-          };
-        }
-      }
-
-      return result;
-    }
-
-    return {
-      status: "fulfilled",
-    };
-  } else if (
-    value._type === "BinaryCoStream" ||
-    value._type === "CoPlainText"
-  ) {
-    return {
-      status: "fulfilled",
-    };
-  } else {
-    console.error(value);
-    throw new Error("Unexpected value type: " + value._type);
-  }
-}
-
 type UnCoNotNull<T> = UnCo<Exclude<T, null>>;
 export type Clean<T> = UnCo<NonNullable<T>>;
 

package/src/coValues/extensions/imageDef.ts

@@ -1,4 +1,4 @@
-import { co, subscriptionsScopes } from "../../internal.js";
+import { co } from "../../internal.js";
 import { FileStream } from "../coFeed.js";
 import { CoMap } from "../coMap.js";
 
@@ -14,12 +14,6 @@ export class ImageDefinition extends CoMap {
     maxWidth?: number;
     targetWidth?: number;
   }): { res: `${number}x${number}`; stream: FileStream } | undefined {
-    if (!subscriptionsScopes.get(this)) {
-      console.warn(
-        "highestResAvailable() only makes sense when used within a subscription.",
-      );
-    }
-
     const resolutions = Object.keys(this).filter((key) =>
       key.match(/^\d+x\d+$/),
     ) as `${number}x${number}`[];

package/src/coValues/group.ts

@@ -22,6 +22,7 @@ import type {
 import {
   CoValueBase,
   Ref,
+  accessChildById,
   co,
   ensureCoValueLoaded,
   loadCoValueWithoutMe,
@@ -85,6 +86,7 @@ export class Group extends CoValueBase implements CoValue {
           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"]>
@@ -95,6 +97,7 @@ export class Group extends CoValueBase implements CoValue {
           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),
     };
@@ -112,7 +115,7 @@ export class Group extends CoValueBase implements CoValue {
       if (!initOwner) throw new Error("No owner provided");
       if (initOwner._type === "Account" && isControlledAccount(initOwner)) {
         const rawOwner = initOwner._raw;
-        raw = rawOwner.createGroup();
+        raw = rawOwner.core.node.createGroup();
       } else {
         throw new Error("Can only construct group as a controlled account");
       }
@@ -181,12 +184,10 @@ export class Group extends CoValueBase implements CoValue {
           accountID as unknown as ID<RegisteredAccount>,
           this._loadedAs,
           refEncodedAccountSchema,
+          this,
         );
-        const accessRef = () => ref.accessFrom(this, "members." + accountID);
 
-        if (!ref.syncLoad()) {
-          console.warn("Account not loaded", accountID);
-        }
+        const group = this;
 
         members.push({
           id: accountID as unknown as ID<Account>,
@@ -194,7 +195,7 @@ export class Group extends CoValueBase implements CoValue {
           ref,
           get account() {
             // Accounts values are non-nullable because are loaded as dependencies
-            return accessRef() as RegisteredAccount;
+            return accessChildById(group, accountID, refEncodedAccountSchema);
           },
         });
       }