jazz-tools 0.13.17 → 0.13.19

package/src/coValues/inbox.ts

@@ -1,11 +1,4 @@
-import {
-  CoID,
-  InviteSecret,
-  RawAccount,
-  RawCoMap,
-  RawControlledAccount,
-  SessionID,
-} from "cojson";
+import { CoID, InviteSecret, RawAccount, RawCoMap, SessionID } from "cojson";
 import { CoStreamItem, RawCoStream } from "cojson";
 import { activeAccountContext } from "../implementation/activeAccountContext.js";
 import { type Account } from "./account.js";
@@ -32,9 +25,9 @@ export function createInboxRoot(account: Account) {
     throw new Error("Account is not controlled");
   }
 
-  const rawAccount = account._raw as RawControlledAccount;
+  const rawAccount = account._raw;
 
-  const group = rawAccount.createGroup();
+  const group = rawAccount.core.node.createGroup();
   const messagesFeed = group.createStream<MessagesStream>();
 
   const inboxRoot = rawAccount.createMap<InboxRoot>();
@@ -386,7 +379,7 @@ async function acceptInvite(invite: string, account?: Account) {
     throw new Error("Account is not controlled");
   }
 
-  await (account._raw as RawControlledAccount).acceptInvite(id, inviteSecret);
+  await account._raw.core.node.acceptInvite(id, inviteSecret);
 
   return id;
 }

package/src/coValues/interfaces.ts

@@ -3,23 +3,15 @@ import type {
   CojsonInternalTypes,
   RawCoValue,
 } from "cojson";
-import { RawAccount } from "cojson";
+import { ControlledAccount, RawAccount } from "cojson";
 import { activeAccountContext } from "../implementation/activeAccountContext.js";
 import { AnonymousJazzAgent } from "../implementation/anonymousJazzAgent.js";
-import {
-  Ref,
-  SubscriptionScope,
-  inspect,
-  subscriptionsScopes,
-} from "../internal.js";
+import { inspect } from "../internal.js";
 import { coValuesCache } from "../lib/cache.js";
+import { SubscriptionScope } from "../subscribe/SubscriptionScope.js";
+import { SubscriptionValue } from "../subscribe/types.js";
 import { type Account } from "./account.js";
-import {
-  RefsToResolve,
-  RefsToResolveStrict,
-  Resolved,
-  fulfillsDepth,
-} from "./deepLoading.js";
+import { RefsToResolve, RefsToResolveStrict, Resolved } from "./deepLoading.js";
 import { type Group } from "./group.js";
 import { RegisteredSchemas } from "./registeredSchemas.js";
 
@@ -46,6 +38,10 @@ export interface CoValue {
   _owner: Account | Group;
   /** @category Internals */
   _raw: RawCoValue;
+
+  /** @internal */
+  _subscriptionScope?: SubscriptionScope<this>;
+
   /** @internal */
   readonly _loadedAs: Account | AnonymousJazzAgent;
   /** @category Stringifying & Inspection */
@@ -93,27 +89,22 @@ export class CoValueBase implements CoValue {
   declare _instanceID: string;
 
   get _owner(): Account | Group {
-    const owner =
+    const owner = coValuesCache.get(this._raw.group, () =>
       this._raw.group instanceof RawAccount
         ? RegisteredSchemas["Account"].fromRaw(this._raw.group)
-        : RegisteredSchemas["Group"].fromRaw(this._raw.group);
-
-    const subScope = subscriptionsScopes.get(this);
-    if (subScope) {
-      subScope.onRefAccessedOrSet(this.id, owner.id);
-      subscriptionsScopes.set(owner, subScope);
-    }
+        : RegisteredSchemas["Group"].fromRaw(this._raw.group),
+    );
 
     return owner;
   }
 
   /** @private */
   get _loadedAs() {
-    const rawAccount = this._raw.core.node.account;
+    const agent = this._raw.core.node.getCurrentAgent();
 
-    if (rawAccount instanceof RawAccount) {
-      return coValuesCache.get(rawAccount, () =>
-        RegisteredSchemas["Account"].fromRaw(rawAccount),
+    if (agent instanceof ControlledAccount) {
+      return coValuesCache.get(agent.account, () =>
+        RegisteredSchemas["Account"].fromRaw(agent.account),
       );
     }
 
@@ -150,12 +141,7 @@ export class CoValueBase implements CoValue {
   castAs<Cl extends CoValueClass & CoValueFromRaw<CoValue>>(
     cl: Cl,
   ): InstanceType<Cl> {
-    const casted = cl.fromRaw(this._raw) as InstanceType<Cl>;
-    const subscriptionScope = subscriptionsScopes.get(this);
-    if (subscriptionScope) {
-      subscriptionsScopes.set(casted, subscriptionScope);
-    }
-    return casted;
+    return cl.fromRaw(this._raw) as InstanceType<Cl>;
   }
 }
 
@@ -194,6 +180,7 @@ export function loadCoValue<
       {
         resolve: options.resolve,
         loadAs: options.loadAs,
+        syncResolution: true,
         onUnavailable: () => {
           resolve(null);
         },
@@ -317,102 +304,58 @@ export function subscribeToCoValue<
     resolve?: RefsToResolveStrict<V, R>;
     loadAs: Account | AnonymousJazzAgent;
     onUnavailable?: () => void;
-    onUnauthorized?: (errorPath: string[]) => void;
+    onUnauthorized?: () => void;
     syncResolution?: boolean;
   },
   listener: SubscribeListener<V, R>,
 ): () => void {
-  const ref = new Ref(id, options.loadAs, { ref: cls, optional: false });
+  const loadAs = options.loadAs ?? activeAccountContext.get();
+  const node = "node" in loadAs ? loadAs.node : loadAs._raw.core.node;
 
-  let unsubscribed = false;
-  let unsubscribe: (() => void) | undefined;
+  const resolve = options.resolve ?? true;
 
-  function subscribe() {
-    const value = ref.getValueWithoutAccessCheck();
+  let unsubscribed = false;
 
-    if (!value) {
-      options.onUnavailable?.();
-      return;
-    }
+  const rootNode = new SubscriptionScope<V>(node, resolve, id as ID<V>, {
+    ref: cls,
+    optional: false,
+  });
 
+  const handleUpdate = (value: SubscriptionValue<V, any>) => {
     if (unsubscribed) return;
 
-    const subscription = new SubscriptionScope(
-      value,
-      cls as CoValueClass<V> & CoValueFromRaw<V>,
-      (update, subscription) => {
-        if (subscription.syncResolution) return;
-
-        if (!ref.hasReadAccess()) {
-          console.error(
-            "Not enough permissions to load / subscribe to CoValue",
-            id,
-          );
-          options.onUnauthorized?.([]);
-          return;
-        }
-
-        let result;
-
-        try {
-          subscription.syncResolution = true;
-          result = fulfillsDepth(options.resolve, update);
-        } catch (e) {
-          console.error(
-            "Failed to load / subscribe to CoValue",
-            e,
-            e instanceof Error ? e.stack : undefined,
-          );
-          options.onUnavailable?.();
-          return;
-        } finally {
-          subscription.syncResolution = false;
-        }
-
-        if (result.status === "unauthorized") {
-          console.error(
-            "Not enough permissions to load / subscribe to CoValue",
-            id,
-            "on path",
-            result.path.join("."),
-            "unaccessible value:",
-            result.id,
-          );
-          options.onUnauthorized?.(result.path);
-          return;
-        }
-
-        if (result.status === "fulfilled") {
-          listener(update as Resolved<V, R>, subscription.unsubscribeAll);
-        }
-      },
-    );
+    if (value.type === "unavailable") {
+      options.onUnavailable?.();
 
-    unsubscribe = subscription.unsubscribeAll;
-  }
+      console.error(value.toString());
+    } else if (value.type === "unauthorized") {
+      options.onUnauthorized?.();
 
-  const sync = options.syncResolution ? ref.syncLoad() : undefined;
+      console.error(value.toString());
+    } else if (value.type === "loaded") {
+      listener(value.value as Resolved<V, R>, unsubscribe);
+    }
+  };
 
-  if (sync) {
-    subscribe();
-  } else {
-    ref
-      .load()
-      .then(() => subscribe())
-      .catch((e) => {
-        console.error(
-          "Failed to load / subscribe to CoValue",
-          e,
-          e instanceof Error ? e.stack : undefined,
-        );
-        options.onUnavailable?.();
+  let shouldDefer = !options.syncResolution;
+
+  rootNode.setListener((value) => {
+    if (shouldDefer) {
+      shouldDefer = false;
+      Promise.resolve().then(() => {
+        handleUpdate(value);
       });
-  }
+    } else {
+      handleUpdate(value);
+    }
+  });
 
-  return function unsubscribeAtAnyPoint() {
+  function unsubscribe() {
     unsubscribed = true;
-    unsubscribe && unsubscribe();
-  };
+    rootNode.destroy();
+  }
+
+  return unsubscribe;
 }
 
 export function createCoValueObservable<

package/src/implementation/createContext.ts

@@ -248,7 +248,7 @@ export async function createJazzContext<Acc extends Account>(options: {
       await authSecretStorage.setWithoutNotify({
         accountID: context.account.id,
         secretSeed,
-        accountSecret: context.node.account.agentSecret,
+        accountSecret: context.node.getCurrentAgent().agentSecret,
         provider: "anonymous",
       });
     }
@@ -268,11 +268,10 @@ export async function createAnonymousJazzContext({
   crypto: CryptoProvider;
 }): Promise<JazzContextWithAgent> {
   const agentSecret = crypto.newRandomAgentSecret();
-  const rawAgent = new ControlledAgent(agentSecret, crypto);
 
   const node = new LocalNode(
-    rawAgent,
-    crypto.newRandomSessionID(rawAgent.id),
+    agentSecret,
+    crypto.newRandomSessionID(crypto.getAgentID(agentSecret)),
     crypto,
   );
 

package/src/implementation/invites.ts

@@ -12,11 +12,11 @@ export function createInviteLink<C extends CoValue>(
   const coValueCore = value._raw.core;
   let currentCoValue = coValueCore;
 
-  while (currentCoValue.header.ruleset.type === "ownedByGroup") {
+  while (currentCoValue.verified.header.ruleset.type === "ownedByGroup") {
     currentCoValue = currentCoValue.getGroup().core;
   }
 
-  const { ruleset, meta } = currentCoValue.header;
+  const { ruleset, meta } = currentCoValue.verified.header;
 
   if (ruleset.type !== "group" || meta?.type === "account") {
     throw new Error("Can't create invite link for object without group");

package/src/implementation/refs.ts

@@ -1,4 +1,3 @@
-import { type CoID, RawAccount, type RawCoValue, RawGroup } from "cojson";
 import { type Account } from "../coValues/account.js";
 import type {
   AnonymousJazzAgent,
@@ -7,153 +6,61 @@ import type {
   RefEncoded,
   UnCo,
 } from "../internal.js";
-import {
-  instantiateRefEncoded,
-  isRefEncoded,
-  subscriptionsScopes,
-} from "../internal.js";
-import { coValuesCache } from "../lib/cache.js";
-
-const TRACE_ACCESSES = false;
+import { isRefEncoded } from "../internal.js";
+import { accessChildById, getSubscriptionScope } from "../subscribe/index.js";
 
 export class Ref<out V extends CoValue> {
   constructor(
     readonly id: ID<V>,
     readonly controlledAccount: Account | AnonymousJazzAgent,
     readonly schema: RefEncoded<V>,
+    readonly parent: CoValue,
   ) {
     if (!isRefEncoded(schema)) {
       throw new Error("Ref must be constructed with a ref schema");
     }
   }
 
-  private getNode() {
-    return "node" in this.controlledAccount
-      ? this.controlledAccount.node
-      : this.controlledAccount._raw.core.node;
-  }
-
-  hasReadAccess() {
-    const node = this.getNode();
-
-    const raw = node.getLoaded(this.id as unknown as CoID<RawCoValue>);
-
-    if (!raw) {
-      return true;
-    }
-
-    if (raw instanceof RawAccount || raw instanceof RawGroup) {
-      return true;
-    }
-
-    const group = raw.core.getGroup();
+  async load(): Promise<V | null> {
+    const subscriptionScope = getSubscriptionScope(this.parent);
 
-    if (group instanceof RawAccount) {
-      if (node.account.id !== group.id) {
-        return false;
-      }
-    } else if (group.myRole() === undefined) {
-      return false;
-    }
-
-    return true;
-  }
-
-  getValueWithoutAccessCheck() {
-    const node = this.getNode();
-    const raw = node.getLoaded(this.id as unknown as CoID<RawCoValue>);
+    subscriptionScope.subscribeToId(this.id, this.schema);
 
-    if (raw) {
-      return coValuesCache.get(raw, () =>
-        instantiateRefEncoded(this.schema, raw),
-      );
-    } else {
-      return null;
-    }
-  }
+    const node = subscriptionScope.childNodes.get(this.id);
 
-  get value() {
-    if (!this.hasReadAccess()) {
+    if (!node) {
       return null;
     }
 
-    return this.getValueWithoutAccessCheck();
-  }
-
-  private async loadHelper(): Promise<V | "unavailable"> {
-    const node =
-      "node" in this.controlledAccount
-        ? this.controlledAccount.node
-        : this.controlledAccount._raw.core.node;
-    const raw = await node.load(this.id as unknown as CoID<RawCoValue>);
-    if (raw === "unavailable") {
-      return "unavailable";
-    } else {
-      return new Ref(this.id, this.controlledAccount, this.schema).value!;
-    }
-  }
-
-  syncLoad(): V | undefined {
-    const node =
-      "node" in this.controlledAccount
-        ? this.controlledAccount.node
-        : this.controlledAccount._raw.core.node;
-
-    const entry = node.coValuesStore.get(
-      this.id as unknown as CoID<RawCoValue>,
-    );
-
-    if (entry.highLevelState === "available") {
-      return new Ref(this.id, this.controlledAccount, this.schema).value!;
-    }
-
-    return undefined;
-  }
+    const value = node.value;
 
-  async load(): Promise<V | undefined> {
-    const result = await this.loadHelper();
-    if (result === "unavailable") {
-      return undefined;
+    if (value?.type === "loaded") {
+      return value.value as V;
     } else {
-      return result;
+      return new Promise((resolve) => {
+        const unsubscribe = node.subscribe((value) => {
+          if (value?.type === "loaded") {
+            unsubscribe();
+            resolve(value.value as V);
+          } else if (value?.type === "unavailable") {
+            unsubscribe();
+            resolve(null);
+          } else if (value?.type === "unauthorized") {
+            unsubscribe();
+            resolve(null);
+          }
+        });
+      });
     }
   }
 
-  accessFrom(fromScopeValue: CoValue, key: string | number | symbol): V | null {
-    const subScope = subscriptionsScopes.get(fromScopeValue);
-
-    subScope?.onRefAccessedOrSet(fromScopeValue.id, this.id);
-    TRACE_ACCESSES &&
-      console.log(subScope?.scopeID, "accessing", fromScopeValue, key, this.id);
-
-    if (this.value && subScope) {
-      subscriptionsScopes.set(this.value, subScope);
-    }
-
-    if (subScope) {
-      const cached = subScope.cachedValues[this.id];
-      if (cached) {
-        TRACE_ACCESSES && console.log("cached", cached);
-        return cached as V;
-      } else if (this.value !== null) {
-        const freshValueInstance = instantiateRefEncoded(
-          this.schema,
-          this.value._raw,
-        );
-        TRACE_ACCESSES && console.log("freshValueInstance", freshValueInstance);
-        subScope.cachedValues[this.id] = freshValueInstance;
-        subscriptionsScopes.set(freshValueInstance, subScope);
-        return freshValueInstance as V;
-      } else {
-        return null;
-      }
-    } else {
-      return this.value;
-    }
+  get value(): V | null | undefined {
+    return accessChildById(this.parent, this.id, this.schema);
   }
 }
 
 export function makeRefs<Keys extends string | number>(
+  parent: CoValue,
   getIdForKey: (key: Keys) => ID<CoValue> | undefined,
   getKeysWithIds: () => Keys[],
   controlledAccount: Account | AnonymousJazzAgent,
@@ -175,6 +82,7 @@ export function makeRefs<Keys extends string | number>(
               getIdForKey(key)!,
               controlledAccount,
               refSchemaForKey(key),
+              parent,
             );
           }
         };
@@ -189,6 +97,7 @@ export function makeRefs<Keys extends string | number>(
         id as ID<CoValue>,
         controlledAccount,
         refSchemaForKey(key as Keys),
+        parent,
       );
     },
     ownKeys() {

package/src/internal.ts

@@ -7,8 +7,7 @@ export * from "./implementation/anonymousJazzAgent.js";
 export * from "./implementation/errors.js";
 export * from "./implementation/refs.js";
 export * from "./implementation/schema.js";
-export * from "./implementation/subscriptionScope.js";
-
+export * from "./subscribe/index.js";
 export * from "./implementation/createContext.js";
 
 import "./implementation/devtoolsFormatters.js";

package/src/subscribe/CoValueCoreSubscription.ts

@@ -0,0 +1,71 @@
+import { CoValueCore, LocalNode, RawCoMap, RawCoValue } from "cojson";
+
+export class CoValueCoreSubscription {
+  _unsubscribe: () => void = () => {};
+  unsubscribed = false;
+
+  value: RawCoMap | undefined;
+
+  constructor(
+    public node: LocalNode,
+    public id: string,
+    public listener: (value: RawCoValue | "unavailable") => void,
+  ) {
+    const entry = this.node.getCoValue(this.id as any);
+
+    if (entry?.isAvailable()) {
+      this.subscribe(entry.getCurrentContent());
+    } else {
+      this.node.loadCoValueCore(this.id as any).then((value) => {
+        if (this.unsubscribed) return;
+
+        if (value.isAvailable()) {
+          this.subscribe(value.getCurrentContent());
+        } else {
+          this.listener("unavailable");
+          this.subscribeToState();
+        }
+      });
+    }
+  }
+
+  subscribeToState() {
+    const entry = this.node.getCoValue(this.id as any);
+    const handleStateChange = (
+      core: CoValueCore,
+      unsubFromStateChange: () => void,
+    ) => {
+      if (this.unsubscribed) {
+        unsubFromStateChange();
+        return;
+      }
+
+      if (core.isAvailable()) {
+        this.subscribe(core.getCurrentContent());
+        unsubFromStateChange();
+      }
+    };
+
+    const unsubFromStateChange = entry.subscribe(handleStateChange);
+
+    this._unsubscribe = () => {
+      unsubFromStateChange();
+    };
+  }
+
+  subscribe(value: RawCoValue) {
+    if (this.unsubscribed) return;
+
+    this._unsubscribe = value.subscribe((value) => {
+      this.listener(value);
+    });
+
+    this.listener(value);
+  }
+
+  unsubscribe() {
+    if (this.unsubscribed) return;
+    this.unsubscribed = true;
+    this._unsubscribe();
+  }
+}

package/src/subscribe/JazzError.ts

@@ -0,0 +1,48 @@
+import type { CoValue, ID } from "../internal.js";
+
+export class JazzError {
+  constructor(
+    public id: ID<CoValue> | undefined,
+    public type: "unavailable" | "unauthorized",
+    public issues: JazzErrorIssue[],
+  ) {}
+
+  toString() {
+    return this.issues
+      .map((issue) => {
+        let message = `${issue.message}`;
+
+        if (this.id) {
+          message += ` from ${this.id}`;
+        }
+
+        if (issue.path.length > 0) {
+          message += ` on path ${issue.path.join(".")}`;
+        }
+
+        return message;
+      })
+      .join("\n");
+  }
+
+  prependPath(item: string) {
+    if (this.issues.length === 0) {
+      return this;
+    }
+
+    const issues = this.issues.map((issue) => {
+      return {
+        ...issue,
+        path: [item].concat(issue.path),
+      };
+    });
+
+    return new JazzError(this.id, this.type, issues);
+  }
+}
+export type JazzErrorIssue = {
+  code: "unavailable" | "unauthorized" | "validationError";
+  message: string;
+  params: Record<string, any>;
+  path: string[];
+};