jazz-tools 0.18.8 → 0.18.11

package/src/react-core/tests/useAccountWithSelector.test.ts

@@ -0,0 +1,411 @@
+// @vitest-environment happy-dom
+
+import { Account, RefsToResolve, co, z } from "jazz-tools";
+import { beforeEach, describe, expect, it } from "vitest";
+import { useAccountWithSelector, useJazzContextManager } from "../hooks.js";
+import { useIsAuthenticated } from "../index.js";
+import {
+  createJazzTestAccount,
+  createJazzTestGuest,
+  setupJazzTestSync,
+} from "../testing.js";
+import { act, renderHook } from "./testUtils.js";
+import { useRef } from "react";
+
+beforeEach(async () => {
+  await setupJazzTestSync();
+});
+
+const useRenderCount = <T>(hook: () => T) => {
+  const renderCountRef = useRef(0);
+  const result = hook();
+  renderCountRef.current = renderCountRef.current + 1;
+  return {
+    renderCount: renderCountRef.current,
+    result,
+  };
+};
+
+describe("useAccountWithSelector", () => {
+  it("should return the correct selected value", async () => {
+    const AccountRoot = co.map({
+      value: z.string(),
+    });
+
+    const AccountSchema = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration((account, creationProps) => {
+        if (!account.$jazz.refs.root) {
+          account.$jazz.set("root", { value: "123" });
+        }
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema,
+    });
+
+    const { result } = renderHook(
+      () =>
+        useAccountWithSelector(AccountSchema, {
+          resolve: {
+            root: true,
+          },
+          select: (account) => account?.root.value ?? "Loading...",
+        }),
+      {
+        account,
+      },
+    );
+
+    expect(result.current).toBe("123");
+  });
+
+  it("should load nested values if requested", async () => {
+    const AccountRoot = co.map({
+      value: z.string(),
+      nested: co.map({
+        nestedValue: z.string(),
+      }),
+    });
+
+    const AccountSchema = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration((account, creationProps) => {
+        if (!account.$jazz.refs.root) {
+          const root = AccountRoot.create({
+            value: "123",
+            nested: co
+              .map({
+                nestedValue: z.string(),
+              })
+              .create({
+                nestedValue: "456",
+              }),
+          });
+          account.$jazz.set("root", root);
+        }
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema,
+    });
+
+    const { result } = renderHook(
+      () =>
+        useAccountWithSelector(AccountSchema, {
+          resolve: {
+            root: {
+              nested: true,
+            },
+          },
+          select: (account) => account?.root.nested.nestedValue ?? "Loading...",
+        }),
+      {
+        account,
+      },
+    );
+
+    expect(result.current).toBe("456");
+  });
+
+  it("should not re-render when a nested coValue is updated and not selected", async () => {
+    const AccountRoot = co.map({
+      value: z.string(),
+      get nested() {
+        return co
+          .map({
+            nestedValue: z.string(),
+          })
+          .optional();
+      },
+    });
+
+    const AccountSchema = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration((account, creationProps) => {
+        if (!account.$jazz.refs.root) {
+          const root = AccountRoot.create({
+            value: "1",
+            nested: co
+              .map({
+                nestedValue: z.string(),
+              })
+              .create({
+                nestedValue: "1",
+              }),
+          });
+          account.$jazz.set("root", root);
+        }
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema,
+    });
+
+    const { result } = renderHook(
+      () =>
+        useRenderCount(() =>
+          useAccountWithSelector(AccountSchema, {
+            resolve: {
+              root: {
+                nested: true,
+              },
+            },
+            select: (account) => account?.root.value ?? "Loading...",
+          }),
+        ),
+      {
+        account,
+      },
+    );
+
+    await act(async () => {
+      // Update nested value that is not selected
+      account.root.nested?.$jazz.set("nestedValue", "100");
+      await account.$jazz.waitForAllCoValuesSync();
+    });
+
+    expect(result.current.result).toEqual("1");
+    expect(result.current.renderCount).toEqual(1);
+  });
+
+  it("should re-render when a nested coValue is updated and selected", async () => {
+    const AccountRoot = co.map({
+      value: z.string(),
+      get nested() {
+        return co
+          .map({
+            nestedValue: z.string(),
+          })
+          .optional();
+      },
+    });
+
+    const AccountSchema = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration((account, creationProps) => {
+        if (!account.$jazz.refs.root) {
+          const root = AccountRoot.create({
+            value: "1",
+            nested: co
+              .map({
+                nestedValue: z.string(),
+              })
+              .create({
+                nestedValue: "1",
+              }),
+          });
+          account.$jazz.set("root", root);
+        }
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema,
+    });
+
+    const { result } = renderHook(
+      () =>
+        useRenderCount(() =>
+          useAccountWithSelector(AccountSchema, {
+            resolve: {
+              root: {
+                nested: true,
+              },
+            },
+            select: (account) =>
+              account?.root?.nested?.nestedValue ?? "Loading...",
+          }),
+        ),
+      {
+        account,
+      },
+    );
+
+    await act(async () => {
+      // Update nested value that is selected
+      account.root?.nested?.$jazz.set("nestedValue", "100");
+      await account.$jazz.waitForAllCoValuesSync();
+    });
+
+    expect(result.current.result).toEqual("100");
+    expect(result.current.renderCount).toEqual(2); // Initial render + update
+  });
+
+  it("should not re-render when equalityFn always returns true", async () => {
+    const AccountRoot = co.map({
+      value: z.string(),
+      get nested() {
+        return co
+          .map({
+            nestedValue: z.string(),
+          })
+          .optional();
+      },
+    });
+
+    const AccountSchema = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration((account, creationProps) => {
+        if (!account.$jazz.refs.root) {
+          const root = AccountRoot.create({
+            value: "1",
+            nested: co
+              .map({
+                nestedValue: z.string(),
+              })
+              .create({
+                nestedValue: "1",
+              }),
+          });
+          account.$jazz.set("root", root);
+        }
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema,
+    });
+
+    const { result } = renderHook(
+      () =>
+        useRenderCount(() =>
+          useAccountWithSelector(AccountSchema, {
+            resolve: {
+              root: {
+                nested: true,
+              },
+            },
+            select: (account) =>
+              account?.root?.nested?.nestedValue ?? "Loading...",
+            equalityFn: () => true, // Always return true to prevent re-renders
+          }),
+        ),
+      {
+        account,
+      },
+    );
+
+    await act(async () => {
+      // Update nested value that is selected
+      account.root?.nested?.$jazz.set("nestedValue", "100");
+      await account.$jazz.waitForAllCoValuesSync();
+    });
+
+    expect(result.current.result).toEqual("1"); // Should still be "1" due to equalityFn
+    expect(result.current.renderCount).toEqual(1); // Should not re-render
+  });
+
+  it("should not load nested values if the account is a guest", async () => {
+    const AccountRoot = co.map({
+      value: z.string(),
+    });
+
+    const AccountSchema = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration((account, creationProps) => {
+        if (!account.$jazz.refs.root) {
+          account.$jazz.set("root", { value: "123" });
+        }
+      });
+
+    const account = await createJazzTestGuest();
+
+    const { result } = renderHook(
+      () =>
+        useAccountWithSelector(AccountSchema, {
+          resolve: {
+            root: true,
+          },
+          select: (account) => account?.root?.value ?? "Guest",
+        }),
+      {
+        account,
+      },
+    );
+
+    expect(result.current).toBe("Guest");
+  });
+
+  it("should handle undefined account gracefully", async () => {
+    const account = await createJazzTestGuest();
+
+    const { result } = renderHook(
+      () =>
+        useAccountWithSelector(Account, {
+          select: (account) => account?.$jazz.id ?? "No account",
+        }),
+      {
+        account,
+      },
+    );
+
+    expect(result.current).toBe("No account");
+  });
+
+  it("should re-render when selector result changes due to external prop changes", async () => {
+    const AccountRoot = co.map({
+      value: z.string(),
+    });
+
+    const AccountSchema = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration((account, creationProps) => {
+        if (!account.$jazz.refs.root) {
+          account.$jazz.set("root", { value: "initial" });
+        }
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema,
+    });
+
+    let externalProp = "suffix1";
+
+    const { result, rerender } = renderHook(
+      () =>
+        useRenderCount(() =>
+          useAccountWithSelector(AccountSchema, {
+            resolve: {
+              root: true,
+            },
+            select: (account) => {
+              const baseValue = account?.root?.value ?? "loading";
+              return `${baseValue}-${externalProp}`;
+            },
+          }),
+        ),
+      {
+        account,
+      },
+    );
+
+    expect(result.current.result).toEqual("initial-suffix1");
+    expect(result.current.renderCount).toEqual(1);
+
+    // Change external prop and rerender
+    externalProp = "suffix2";
+    rerender();
+
+    expect(result.current.result).toEqual("initial-suffix2");
+  });
+});

package/src/react-native-core/hooks.tsx

@@ -14,6 +14,7 @@ export {
   useIsAuthenticated,
   useAccount,
   useCoStateWithSelector,
+  useAccountWithSelector,
 } from "jazz-tools/react-core";
 
 export function useAcceptInviteNative<S extends CoValueClassOrSchema>({

package/src/svelte/jazz.svelte.ts

@@ -8,7 +8,7 @@ import type {
 } from "jazz-tools";
 import { Account } from "jazz-tools";
 import { consumeInviteLinkFromWindowLocation } from "jazz-tools/browser";
-import { getContext, untrack } from "svelte";
+import { getContext, onDestroy, untrack } from "svelte";
 import Provider from "./Provider.svelte";
 
 export { Provider as JazzSvelteProvider };
@@ -73,37 +73,33 @@ export class InviteListener<V extends CoValueClassOrSchema> {
     forValueHint,
   }: {
     invitedObjectSchema: V;
-    onAccept: (projectID: ID<V>) => void;
+    onAccept: (coValueID: ID<V>) => void;
     forValueHint?: string;
   }) {
-    // TODO Listen to the hashchange event
     const _onAccept = onAccept;
+    const ctx = getJazzContext<InstanceOfSchema<AccountClass<Account>>>();
 
-    // Subscribe to the onAccept function.
+    const tryConsume = () => {
+      if (!ctx.current || !("me" in ctx.current)) return;
+
+      consumeInviteLinkFromWindowLocation({
+        as: ctx.current.me,
+        invitedObjectSchema,
+        forValueHint,
+      })
+        .then((result) => result && _onAccept(result.valueID))
+        .catch((e) => console.error("Failed to accept invite", e));
+    };
+
+    // run once when instantiated
     $effect(() => {
-      const ctx = getJazzContext<InstanceOfSchema<AccountClass<Account>>>();
-
-      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-      _onAccept;
-      // Subscribe to the onAccept function.
-      untrack(() => {
-        // If there is no context, return.
-        if (!ctx.current) return;
-        if (!("me" in ctx.current)) return;
-
-        // Consume the invite link from the window location.
-        const result = consumeInviteLinkFromWindowLocation({
-          as: ctx.current.me,
-          invitedObjectSchema,
-          forValueHint,
-        });
-        // If the result is valid, call the onAccept function.
-        result
-          .then((result) => result && _onAccept(result?.valueID))
-          .catch((e) => {
-            console.error("Failed to accept invite", e);
-          });
-      });
+      untrack(tryConsume);
+    });
+
+    window.addEventListener("hashchange", tryConsume);
+
+    onDestroy(() => {
+      window.removeEventListener("hashchange", tryConsume);
     });
   }
 }

package/src/tools/implementation/ContextManager.ts

@@ -68,10 +68,9 @@ export class JazzContextManager<
   protected authSecretStorage = new AuthSecretStorage();
   protected keepContextOpen = false;
   contextPromise: Promise<void> | undefined;
+  protected authenticatingAccountID: string | null = null;
 
-  constructor(opts?: {
-    useAnonymousFallback?: boolean;
-  }) {
+  constructor(opts?: { useAnonymousFallback?: boolean }) {
     KvStoreContext.getInstance().initialize(this.getKvStore());
 
     if (opts?.useAnonymousFallback) {
@@ -163,11 +162,17 @@ export class JazzContextManager<
     return this.authSecretStorage;
   }
 
+  getAuthenticatingAccountID() {
+    return this.authenticatingAccountID;
+  }
+
   logOut = async () => {
     if (!this.context || !this.props) {
       return;
     }
 
+    this.authenticatingAccountID = null;
+
     await this.props.onLogOut?.();
 
     if (this.props.logOutReplacement) {
@@ -206,17 +211,44 @@ export class JazzContextManager<
       throw new Error("Props required");
     }
 
-    const prevContext = this.context;
-    const migratingAnonymousAccount =
-      await this.shouldMigrateAnonymousAccount();
+    if (
+      this.authenticatingAccountID &&
+      this.authenticatingAccountID === credentials.accountID
+    ) {
+      console.info(
+        "Authentication already in progress for account",
+        credentials.accountID,
+        "skipping duplicate request",
+      );
+      return;
+    }
+
+    if (
+      this.authenticatingAccountID &&
+      this.authenticatingAccountID !== credentials.accountID
+    ) {
+      throw new Error(
+        `Authentication already in progress for different account (${this.authenticatingAccountID}), cannot authenticate ${credentials.accountID}`,
+      );
+    }
+
+    this.authenticatingAccountID = credentials.accountID;
+
+    try {
+      const prevContext = this.context;
+      const migratingAnonymousAccount =
+        await this.shouldMigrateAnonymousAccount();
 
-    this.keepContextOpen = migratingAnonymousAccount;
-    await this.createContext(this.props, { credentials }).finally(() => {
-      this.keepContextOpen = false;
-    });
+      this.keepContextOpen = migratingAnonymousAccount;
+      await this.createContext(this.props, { credentials }).finally(() => {
+        this.keepContextOpen = false;
+      });
 
-    if (migratingAnonymousAccount) {
-      await this.handleAnonymousAccountMigration(prevContext);
+      if (migratingAnonymousAccount) {
+        await this.handleAnonymousAccountMigration(prevContext);
+      }
+    } finally {
+      this.authenticatingAccountID = null;
     }
   };
 
@@ -228,29 +260,40 @@ export class JazzContextManager<
       throw new Error("Props required");
     }
 
-    const prevContext = this.context;
-    const migratingAnonymousAccount =
-      await this.shouldMigrateAnonymousAccount();
-
-    this.keepContextOpen = migratingAnonymousAccount;
-    await this.createContext(this.props, {
-      newAccountProps: {
-        secret: accountSecret,
-        creationProps,
-      },
-    }).finally(() => {
-      this.keepContextOpen = false;
-    });
-
-    if (migratingAnonymousAccount) {
-      await this.handleAnonymousAccountMigration(prevContext);
+    if (this.authenticatingAccountID) {
+      throw new Error("Authentication already in progress");
     }
 
-    if (this.context && "me" in this.context) {
-      return this.context.me.$jazz.id;
-    }
+    // For registration, we don't know the account ID yet, so we'll set it to "register"
+    this.authenticatingAccountID = "register";
 
-    throw new Error("The registration hasn't created a new account");
+    try {
+      const prevContext = this.context;
+      const migratingAnonymousAccount =
+        await this.shouldMigrateAnonymousAccount();
+
+      this.keepContextOpen = migratingAnonymousAccount;
+      await this.createContext(this.props, {
+        newAccountProps: {
+          secret: accountSecret,
+          creationProps,
+        },
+      }).finally(() => {
+        this.keepContextOpen = false;
+      });
+
+      if (migratingAnonymousAccount) {
+        await this.handleAnonymousAccountMigration(prevContext);
+      }
+
+      if (this.context && "me" in this.context) {
+        return this.context.me.$jazz.id;
+      }
+
+      throw new Error("The registration hasn't created a new account");
+    } finally {
+      this.authenticatingAccountID = null;
+    }
   };
 
   private async handleAnonymousAccountMigration(