jazz-tools 0.11.8 → 0.12.1

package/src/coValues/interfaces.ts

@@ -6,7 +6,6 @@ import type {
 import { RawAccount } from "cojson";
 import { activeAccountContext } from "../implementation/activeAccountContext.js";
 import { AnonymousJazzAgent } from "../implementation/anonymousJazzAgent.js";
-import type { DeeplyLoaded, DepthsIn } from "../internal.js";
 import {
   Ref,
   SubscriptionScope,
@@ -15,7 +14,12 @@ import {
 } from "../internal.js";
 import { coValuesCache } from "../lib/cache.js";
 import { type Account } from "./account.js";
-import { fulfillsDepth } from "./deepLoading.js";
+import {
+  RefsToResolve,
+  RefsToResolveStrict,
+  Resolved,
+  fulfillsDepth,
+} from "./deepLoading.js";
 import { type Group } from "./group.js";
 import { RegisteredSchemas } from "./registeredSchemas.js";
 
@@ -155,56 +159,70 @@ export class CoValueBase implements CoValue {
   }
 }
 
-export function loadCoValueWithoutMe<V extends CoValue, Depth>(
+export function loadCoValueWithoutMe<
+  V extends CoValue,
+  const R extends RefsToResolve<V>,
+>(
   cls: CoValueClass<V>,
   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(
-        "Depth is required when loading a CoValue as an Account or AnonymousJazzAgent",
-      );
-    }
-    return loadCoValue(cls, id, asOrDepth, depth);
-  }
-
-  return loadCoValue(cls, id, activeAccountContext.get(), asOrDepth);
+  options?: {
+    resolve?: RefsToResolveStrict<V, R>;
+    loadAs?: Account | AnonymousJazzAgent;
+  },
+): Promise<Resolved<V, R> | null> {
+  return loadCoValue(cls, id, {
+    ...options,
+    loadAs: options?.loadAs ?? activeAccountContext.get(),
+  });
 }
 
-export function loadCoValue<V extends CoValue, Depth>(
+export function loadCoValue<
+  V extends CoValue,
+  const R extends RefsToResolve<V>,
+>(
   cls: CoValueClass<V>,
   id: ID<CoValue>,
-  as: Account | AnonymousJazzAgent,
-  depth: Depth & DepthsIn<V>,
-): Promise<DeeplyLoaded<V, Depth> | undefined> {
+  options: {
+    resolve?: RefsToResolveStrict<V, R>;
+    loadAs: Account | AnonymousJazzAgent;
+  },
+): Promise<Resolved<V, R> | null> {
   return new Promise((resolve) => {
-    subscribeToCoValue(
+    subscribeToCoValue<V, R>(
       cls,
       id,
-      as,
-      depth,
+      {
+        resolve: options.resolve,
+        loadAs: options.loadAs,
+        onUnavailable: () => {
+          resolve(null);
+        },
+        onUnauthorized: () => {
+          resolve(null);
+        },
+      },
       (value, unsubscribe) => {
         resolve(value);
         unsubscribe();
       },
-      () => {
-        resolve(undefined);
-      },
     );
   });
 }
 
-export async function ensureCoValueLoaded<V extends CoValue, Depth>(
+export async function ensureCoValueLoaded<
+  V extends CoValue,
+  const R extends RefsToResolve<V>,
+>(
   existing: V,
-  depth: Depth & DepthsIn<V>,
-): Promise<DeeplyLoaded<V, Depth>> {
+  options?: { resolve?: RefsToResolveStrict<V, R> } | undefined,
+): Promise<Resolved<V, R>> {
   const response = await loadCoValue(
     existing.constructor as CoValueClass<V>,
     existing.id,
-    existing._loadedAs,
-    depth,
+    {
+      loadAs: existing._loadedAs,
+      resolve: options?.resolve,
+    },
   );
 
   if (!response) {
@@ -214,81 +232,146 @@ export async function ensureCoValueLoaded<V extends CoValue, Depth>(
   return response;
 }
 
-export function subscribeToCoValueWithoutMe<V extends CoValue, Depth>(
-  cls: CoValueClass<V>,
-  id: ID<CoValue>,
-  asOrDepth: Account | AnonymousJazzAgent | (Depth & DepthsIn<V>),
-  depthOrListener:
-    | (Depth & DepthsIn<V>)
-    | ((value: DeeplyLoaded<V, Depth>) => void),
-  listener?: (value: DeeplyLoaded<V, Depth>) => void,
-) {
-  if (isAccountInstance(asOrDepth) || isAnonymousAgentInstance(asOrDepth)) {
-    if (typeof depthOrListener !== "function") {
-      return subscribeToCoValue<V, Depth>(
-        cls,
-        id,
-        asOrDepth,
-        depthOrListener,
-        listener!,
-      );
+type SubscribeListener<V extends CoValue, R extends RefsToResolve<V>> = (
+  value: Resolved<V, R>,
+  unsubscribe: () => void,
+) => void;
+
+export type SubscribeListenerOptions<
+  V extends CoValue,
+  R extends RefsToResolve<V>,
+> = {
+  resolve?: RefsToResolveStrict<V, R>;
+  loadAs?: Account | AnonymousJazzAgent;
+  onUnauthorized?: () => void;
+  onUnavailable?: () => void;
+};
+
+export type SubscribeRestArgs<V extends CoValue, R extends RefsToResolve<V>> =
+  | [options: SubscribeListenerOptions<V, R>, listener: SubscribeListener<V, R>]
+  | [listener: SubscribeListener<V, R>];
+
+export function parseSubscribeRestArgs<
+  V extends CoValue,
+  R extends RefsToResolve<V>,
+>(
+  args: SubscribeRestArgs<V, R>,
+): {
+  options: SubscribeListenerOptions<V, R>;
+  listener: SubscribeListener<V, R>;
+} {
+  if (args.length === 2) {
+    if (
+      typeof args[0] === "object" &&
+      args[0] &&
+      typeof args[1] === "function"
+    ) {
+      return {
+        options: {
+          resolve: args[0].resolve,
+          loadAs: args[0].loadAs,
+          onUnauthorized: args[0].onUnauthorized,
+          onUnavailable: args[0].onUnavailable,
+        },
+        listener: args[1],
+      };
+    } else {
+      throw new Error("Invalid arguments");
+    }
+  } else {
+    if (typeof args[0] === "function") {
+      return { options: {}, listener: args[0] };
+    } else {
+      throw new Error("Invalid arguments");
     }
-    throw new Error("Invalid arguments");
-  }
-
-  if (typeof depthOrListener !== "function") {
-    throw new Error("Invalid arguments");
   }
+}
 
-  return subscribeToCoValue<V, Depth>(
+export function subscribeToCoValueWithoutMe<
+  V extends CoValue,
+  const R extends RefsToResolve<V>,
+>(
+  cls: CoValueClass<V>,
+  id: ID<CoValue>,
+  options: SubscribeListenerOptions<V, R>,
+  listener: SubscribeListener<V, R>,
+) {
+  return subscribeToCoValue(
     cls,
     id,
-    activeAccountContext.get(),
-    asOrDepth,
-    depthOrListener,
+    {
+      ...options,
+      loadAs: options.loadAs ?? activeAccountContext.get(),
+    },
+    listener,
   );
 }
 
-export function subscribeToCoValue<V extends CoValue, Depth>(
+export function subscribeToCoValue<
+  V extends CoValue,
+  const R extends RefsToResolve<V>,
+>(
   cls: CoValueClass<V>,
   id: ID<CoValue>,
-  as: Account | AnonymousJazzAgent,
-  depth: Depth & DepthsIn<V>,
-  listener: (value: DeeplyLoaded<V, Depth>, unsubscribe: () => void) => void,
-  onUnavailable?: () => void,
-  syncResolution?: boolean,
+  options: {
+    resolve?: RefsToResolveStrict<V, R>;
+    loadAs: Account | AnonymousJazzAgent;
+    onUnavailable?: () => void;
+    onUnauthorized?: () => void;
+    syncResolution?: boolean;
+  },
+  listener: SubscribeListener<V, R>,
 ): () => void {
-  const ref = new Ref(id, as, { ref: cls, optional: false });
+  const ref = new Ref(id, options.loadAs, { ref: cls, optional: false });
 
   let unsubscribed = false;
   let unsubscribe: (() => void) | undefined;
 
-  function subscribe(value: CoValue | undefined) {
+  function subscribe() {
+    const value = ref.getValueWithoutAccessCheck();
+
     if (!value) {
-      onUnavailable && onUnavailable();
+      options.onUnavailable?.();
       return;
     }
+
     if (unsubscribed) return;
 
     const subscription = new SubscriptionScope(
       value,
       cls as CoValueClass<V> & CoValueFromRaw<V>,
       (update, subscription) => {
-        // fullfillsDepth may trigger a syncronous update while accessing values
-        // we want to discard those to avoid invalid updates
-        if (subscription.syncResolution) return false;
-
-        // Enabling syncResolution during fullfillsDepth access to block any
-        // unnecessery update triggers related to in-memory values
-        subscription.syncResolution = true;
-        const isLoaded = fulfillsDepth(depth, update);
-        subscription.syncResolution = false;
-
-        if (isLoaded) {
-          listener(
-            update as DeeplyLoaded<V, Depth>,
-            subscription.unsubscribeAll,
+        if (subscription.syncResolution) return;
+
+        if (!ref.hasReadAccess()) {
+          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 === "unauthorized") {
+          options.onUnauthorized?.();
+          return;
+        }
+
+        if (result === "fulfilled") {
+          listener(update as Resolved<V, R>, subscription.unsubscribeAll);
         }
       },
     );
@@ -296,17 +379,21 @@ export function subscribeToCoValue<V extends CoValue, Depth>(
     unsubscribe = subscription.unsubscribeAll;
   }
 
-  const sync = syncResolution ? ref.syncLoad() : undefined;
+  const sync = options.syncResolution ? ref.syncLoad() : undefined;
 
   if (sync) {
-    subscribe(sync);
+    subscribe();
   } else {
     ref
       .load()
-      .then((value) => subscribe(value))
+      .then(() => subscribe())
       .catch((e) => {
-        console.error("Failed to load / subscribe to CoValue", e);
-        onUnavailable?.();
+        console.error(
+          "Failed to load / subscribe to CoValue",
+          e,
+          e instanceof Error ? e.stack : undefined,
+        );
+        options.onUnavailable?.();
       });
   }
 
@@ -316,36 +403,47 @@ export function subscribeToCoValue<V extends CoValue, Depth>(
   };
 }
 
-export function createCoValueObservable<V extends CoValue, Depth>(options?: {
-  syncResolution?: boolean;
-}) {
-  let currentValue: DeeplyLoaded<V, Depth> | undefined | null = undefined;
+export function createCoValueObservable<
+  V extends CoValue,
+  const R extends RefsToResolve<V>,
+>() {
+  let currentValue: Resolved<V, R> | undefined | null = undefined;
   let subscriberCount = 0;
 
   function subscribe(
     cls: CoValueClass<V>,
     id: ID<CoValue>,
-    as: Account | AnonymousJazzAgent,
-    depth: Depth & DepthsIn<V>,
+    options: {
+      loadAs: Account | AnonymousJazzAgent;
+      resolve?: RefsToResolveStrict<V, R>;
+      onUnavailable?: () => void;
+      onUnauthorized?: () => void;
+      syncResolution?: boolean;
+    },
     listener: () => void,
-    onUnavailable?: () => void,
   ) {
     subscriberCount++;
 
     const unsubscribe = subscribeToCoValue(
       cls,
       id,
-      as,
-      depth,
+      {
+        loadAs: options.loadAs,
+        resolve: options.resolve,
+        onUnavailable: () => {
+          currentValue = null;
+          options.onUnavailable?.();
+        },
+        onUnauthorized: () => {
+          currentValue = null;
+          options.onUnauthorized?.();
+        },
+        syncResolution: options.syncResolution,
+      },
       (value) => {
         currentValue = value;
         listener();
       },
-      () => {
-        currentValue = null;
-        onUnavailable?.();
-      },
-      options?.syncResolution,
     );
 
     return () => {
@@ -365,16 +463,29 @@ export function createCoValueObservable<V extends CoValue, Depth>(options?: {
   return observable;
 }
 
-export function subscribeToExistingCoValue<V extends CoValue, Depth>(
+export function subscribeToExistingCoValue<
+  V extends CoValue,
+  const R extends RefsToResolve<V>,
+>(
   existing: V,
-  depth: Depth & DepthsIn<V>,
-  listener: (value: DeeplyLoaded<V, Depth>) => void,
+  options:
+    | {
+        resolve?: RefsToResolveStrict<V, R>;
+        onUnavailable?: () => void;
+        onUnauthorized?: () => void;
+      }
+    | undefined,
+  listener: SubscribeListener<V, R>,
 ): () => void {
   return subscribeToCoValue(
     existing.constructor as CoValueClass<V>,
     existing.id,
-    existing._loadedAs,
-    depth,
+    {
+      loadAs: existing._loadedAs,
+      resolve: options?.resolve,
+      onUnavailable: options?.onUnavailable,
+      onUnauthorized: options?.onUnauthorized,
+    },
     listener,
   );
 }

package/src/exports.ts

@@ -43,7 +43,13 @@ export { CoValueBase } from "./coValues/interfaces.js";
 export { Profile } from "./coValues/profile.js";
 export { SchemaUnion } from "./coValues/schemaUnion.js";
 
-export type { CoValueClass, DeeplyLoaded, DepthsIn } from "./internal.js";
+export type {
+  CoValueClass,
+  DeeplyLoaded,
+  Resolved,
+  RefsToResolve,
+  RefsToResolveStrict,
+} from "./internal.js";
 
 export {
   createCoValueObservable,

package/src/implementation/refs.ts

@@ -1,4 +1,4 @@
-import type { CoID, RawCoValue } from "cojson";
+import { type CoID, RawAccount, type RawCoValue, RawGroup } from "cojson";
 import { type Account } from "../coValues/account.js";
 import type {
   AnonymousJazzAgent,
@@ -27,12 +27,42 @@ export class Ref<out V extends CoValue> {
     }
   }
 
-  get value() {
-    const node =
-      "node" in this.controlledAccount
-        ? this.controlledAccount.node
-        : this.controlledAccount._raw.core.node;
+  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();
+
+    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>);
+
     if (raw) {
       return coValuesCache.get(raw, () =>
         instantiateRefEncoded(this.schema, raw),
@@ -42,6 +72,14 @@ export class Ref<out V extends CoValue> {
     }
   }
 
+  get value() {
+    if (!this.hasReadAccess()) {
+      return null;
+    }
+
+    return this.getValueWithoutAccessCheck();
+  }
+
   private async loadHelper(): Promise<V | "unavailable"> {
     const node =
       "node" in this.controlledAccount
@@ -100,7 +138,7 @@ export class Ref<out V extends CoValue> {
       } else if (this.value !== null) {
         const freshValueInstance = instantiateRefEncoded(
           this.schema,
-          this.value?._raw,
+          this.value._raw,
         );
         TRACE_ACCESSES && console.log("freshValueInstance", freshValueInstance);
         subScope.cachedValues[this.id] = freshValueInstance;

package/src/testing.ts

@@ -271,7 +271,7 @@ export class TestJazzContextManager<
   }
 }
 
-export function linkAccounts(
+export async function linkAccounts(
   a: Account,
   b: Account,
   aRole: "server" | "client" = "server",
@@ -284,6 +284,9 @@ export function linkAccounts(
 
   a._raw.core.node.syncManager.addPeer(aPeer);
   b._raw.core.node.syncManager.addPeer(bPeer);
+
+  await a.waitForAllCoValuesSync();
+  await b.waitForAllCoValuesSync();
 }
 
 export async function setupJazzTestSync() {

package/src/tests/ContextManager.test.ts

@@ -247,7 +247,9 @@ describe("ContextManager", () => {
       provider: "test",
     });
 
-    const me = await CustomAccount.getMe().ensureLoaded({ root: {} });
+    const me = await CustomAccount.getMe().ensureLoaded({
+      resolve: { root: true },
+    });
 
     expect(me.root.id).toBe(lastRootId);
   });
@@ -266,7 +268,7 @@ describe("ContextManager", () => {
             value: 1,
           });
         } else {
-          const { root } = await this.ensureLoaded({ root: {} });
+          const { root } = await this.ensureLoaded({ resolve: { root: true } });
 
           root.value = 2;
         }
@@ -289,7 +291,9 @@ describe("ContextManager", () => {
       provider: "test",
     });
 
-    const me = await CustomAccount.getMe().ensureLoaded({ root: {} });
+    const me = await CustomAccount.getMe().ensureLoaded({
+      resolve: { root: true },
+    });
 
     expect(me.root.value).toBe(2);
   });
@@ -316,10 +320,16 @@ describe("ContextManager", () => {
       anonymousAccount: CustomAccount,
     ) => {
       const anonymousAccountWithRoot = await anonymousAccount.ensureLoaded({
-        root: {},
+        resolve: {
+          root: true,
+        },
       });
 
-      const meWithRoot = await CustomAccount.getMe().ensureLoaded({ root: {} });
+      const meWithRoot = await CustomAccount.getMe().ensureLoaded({
+        resolve: {
+          root: true,
+        },
+      });
 
       const rootToTransfer = anonymousAccountWithRoot.root;
 
@@ -347,7 +357,11 @@ describe("ContextManager", () => {
       provider: "test",
     });
 
-    const me = await CustomAccount.getMe().ensureLoaded({ root: {} });
+    const me = await CustomAccount.getMe().ensureLoaded({
+      resolve: {
+        root: true,
+      },
+    });
 
     expect(me.root.transferredRoot?.value).toBe("Hello");
   });

package/src/tests/PassphraseAuth.test.ts

@@ -152,7 +152,9 @@ describe("PassphraseAuth", () => {
 
       // Verify the account name was set
       const { profile } = await account.ensureLoaded({
-        profile: {},
+        resolve: {
+          profile: true,
+        },
       });
       expect(profile.name).toBe(testName);
 

package/src/tests/account.test.ts

@@ -1,6 +1,10 @@
 import { expect, test } from "vitest";
-import { Account, CoMap, co } from "../exports.js";
-import { createJazzTestAccount, setActiveAccount } from "../testing.js";
+import { Account, CoMap, Group, co } from "../exports.js";
+import {
+  createJazzTestAccount,
+  linkAccounts,
+  setActiveAccount,
+} from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
 
 test("waitForAllCoValuesSync should resolve when all the values are synced", async () => {
@@ -74,3 +78,23 @@ test("Me gets updated correctly when creating a new account as active", async ()
   expect(newMe.isMe).toBe(true);
   expect(oldMe.isMe).toBe(false);
 });
+
+test("accounts should sync correctly", async () => {
+  const account = await createJazzTestAccount({ isCurrentActiveAccount: true });
+  account.profile!.name = "test 1";
+  const otherAccount = await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+  });
+  otherAccount.profile!.name = "test 2";
+
+  await linkAccounts(account, otherAccount);
+
+  const group = Group.create({ owner: account });
+
+  group.addMember(otherAccount, "writer");
+
+  const { members } = group;
+
+  expect(members[0]?.account.profile!.name).toBe("test 1");
+  expect(members[1]?.account.profile!.name).toBe("test 2");
+});