jazz-tools 0.18.8 → 0.18.11

package/src/better-auth/auth/tests/client.test.ts

@@ -2,6 +2,7 @@ import { createAuthClient } from "better-auth/client";
 import type { Account, AuthSecretStorage } from "jazz-tools";
 import {
   TestJazzContextManager,
+  createJazzTestAccount,
   setActiveAccount,
   setupJazzTestSync,
 } from "jazz-tools/testing";
@@ -334,4 +335,232 @@ describe("Better-Auth client plugin", () => {
       }),
     );
   });
+
+  describe("Race condition handling", () => {
+    it("should handle multiple concurrent get-session calls without errors", async () => {
+      const credentials = await authSecretStorage.get();
+      assert(credentials, "Jazz credentials are not available");
+
+      // Mock multiple get-session responses with fresh Response objects
+      customFetchImpl.mockImplementation(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              user: {
+                id: "YW5kcmVpYnVkb2k",
+                email: "test@jazz.dev",
+                name: "andreibudoi",
+                accountID: credentials.accountID,
+              },
+              jazzAuth: {
+                accountID: credentials.accountID,
+                secretSeed: credentials.secretSeed,
+                accountSecret: credentials.accountSecret,
+                provider: "better-auth",
+              },
+            }),
+          ),
+        ),
+      );
+
+      // Simulate multiple concurrent get-session calls (like during OAuth)
+      const promises = [];
+      for (let i = 0; i < 5; i++) {
+        promises.push(authClient.$fetch("/get-session", { method: "GET" }));
+      }
+
+      // Should complete without errors due to race condition handling
+      await expect(Promise.all(promises)).resolves.toBeDefined();
+
+      // Should have been called multiple times by better-auth
+      expect(customFetchImpl).toHaveBeenCalledTimes(5);
+
+      // User should be authenticated
+      expect(authSecretStorage.isAuthenticated).toBe(true);
+    });
+
+    it("should handle credentials mismatch scenario without errors", async () => {
+      const originalCredentials = await authSecretStorage.get();
+      assert(originalCredentials, "Jazz credentials are not available");
+
+      // Create a test account for the mismatch scenario
+      const testAccount = await createJazzTestAccount();
+
+      // Mock get-session response with different account using fresh Response objects
+      customFetchImpl.mockImplementation(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              user: {
+                id: "RGlmZmVyZW50IFVzZXI",
+                email: "different@jazz.dev",
+                name: "Different User",
+                accountID: testAccount.$jazz.id,
+              },
+              jazzAuth: {
+                accountID: testAccount.$jazz.id,
+                secretSeed: new Uint8Array([4, 5, 6]),
+                accountSecret:
+                  testAccount.$jazz.localNode.getCurrentAgent().agentSecret,
+                provider: "better-auth",
+              },
+            }),
+          ),
+        ),
+      );
+
+      // Simulate multiple concurrent get-session calls with mismatched credentials
+      const promises = [];
+      for (let i = 0; i < 3; i++) {
+        promises.push(authClient.$fetch("/get-session", { method: "GET" }));
+      }
+
+      // Should complete without errors despite credential mismatch
+      await expect(Promise.all(promises)).resolves.toBeDefined();
+
+      // Should have been called multiple times by better-auth
+      expect(customFetchImpl).toHaveBeenCalledTimes(3);
+
+      // Should be authenticated with the new account
+      expect(authSecretStorage.isAuthenticated).toBe(true);
+      const currentCredentials = await authSecretStorage.get();
+      expect(currentCredentials?.accountID).toBe(testAccount.$jazz.id);
+    });
+
+    it("should allow authentication after sign out without being blocked", async () => {
+      const credentials = await authSecretStorage.get();
+      assert(credentials, "Jazz credentials are not available");
+
+      const getSessionResponseData = {
+        user: {
+          id: "123",
+          accountID: credentials.accountID,
+        },
+        jazzAuth: {
+          accountID: credentials.accountID,
+          secretSeed: credentials.secretSeed,
+          accountSecret: credentials.accountSecret,
+          provider: "better-auth",
+        },
+      };
+
+      // First authenticate
+      customFetchImpl.mockResolvedValueOnce(
+        new Response(JSON.stringify(getSessionResponseData)),
+      );
+
+      await authClient.$fetch("/get-session", { method: "GET" });
+      expect(authSecretStorage.isAuthenticated).toBe(true);
+
+      // Then sign out
+      customFetchImpl.mockResolvedValueOnce(
+        new Response(JSON.stringify({ success: true })),
+      );
+
+      await authClient.signOut();
+      expect(authSecretStorage.isAuthenticated).toBe(false);
+
+      // Authenticating again should work without being blocked
+      customFetchImpl.mockResolvedValueOnce(
+        new Response(JSON.stringify(getSessionResponseData)),
+      );
+
+      // Should complete without hanging or errors
+      await expect(
+        authClient.$fetch("/get-session", { method: "GET" }),
+      ).resolves.toBeDefined();
+
+      expect(authSecretStorage.isAuthenticated).toBe(true);
+    });
+
+    it("should fail fast when trying to authenticate different accounts concurrently", async () => {
+      const originalCredentials = await authSecretStorage.get();
+      assert(originalCredentials, "Jazz credentials are not available");
+
+      const testAccount1 = await createJazzTestAccount();
+      const testAccount2 = await createJazzTestAccount();
+      const testAccount3 = await createJazzTestAccount();
+
+      const accounts = [testAccount1, testAccount2, testAccount3];
+      let callCount = 0;
+
+      customFetchImpl.mockImplementation(() => {
+        const accountIndex = callCount % 3;
+        const account = accounts[accountIndex]!;
+        callCount++;
+
+        return Promise.resolve(
+          new Response(
+            JSON.stringify({
+              user: {
+                id: `user-${accountIndex + 1}`,
+                email: `user${accountIndex + 1}@jazz.dev`,
+                name: `User ${accountIndex + 1}`,
+                accountID: account.$jazz.id,
+              },
+              jazzAuth: {
+                accountID: account.$jazz.id,
+                secretSeed: new Uint8Array([
+                  accountIndex + 1,
+                  accountIndex + 2,
+                  accountIndex + 3,
+                ]),
+                accountSecret:
+                  account.$jazz.localNode.getCurrentAgent().agentSecret,
+                provider: "better-auth",
+              },
+            }),
+          ),
+        );
+      });
+
+      const promises = [];
+      for (let i = 0; i < 3; i++) {
+        promises.push(authClient.$fetch("/get-session", { method: "GET" }));
+      }
+
+      await expect(Promise.all(promises)).rejects.toThrow();
+
+      expect(customFetchImpl).toHaveBeenCalledTimes(3);
+    });
+
+    it("should deduplicate auth requests for the same account", async () => {
+      const credentials = await authSecretStorage.get();
+      assert(credentials, "Jazz credentials are not available");
+
+      customFetchImpl.mockImplementation(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              user: {
+                id: "test-user",
+                email: "test@jazz.dev",
+                name: "Test User",
+                accountID: credentials.accountID,
+              },
+              jazzAuth: {
+                accountID: credentials.accountID,
+                secretSeed: credentials.secretSeed,
+                accountSecret: credentials.accountSecret,
+                provider: "better-auth",
+              },
+            }),
+          ),
+        ),
+      );
+
+      const promises = [];
+      for (let i = 0; i < 3; i++) {
+        promises.push(authClient.$fetch("/get-session", { method: "GET" }));
+      }
+
+      await expect(Promise.all(promises)).resolves.toBeDefined();
+
+      expect(customFetchImpl).toHaveBeenCalledTimes(3);
+
+      expect(authSecretStorage.isAuthenticated).toBe(true);
+      const finalCredentials = await authSecretStorage.get();
+      expect(finalCredentials?.accountID).toBe(credentials.accountID);
+    });
+  });
 });

package/src/react/hooks.tsx

@@ -51,4 +51,5 @@ export {
   useJazzContext,
   useAccount,
   useCoStateWithSelector,
+  useAccountWithSelector,
 } from "jazz-tools/react-core";

package/src/react/index.ts

@@ -8,6 +8,7 @@ export {
   useJazzContext,
   useAuthSecretStorage,
   useCoStateWithSelector,
+  useAccountWithSelector,
 } from "./hooks.js";
 
 export { createInviteLink, parseInviteLink } from "jazz-tools/browser";

package/src/react-core/hooks.ts

@@ -580,6 +580,90 @@ export function useAccount<
   };
 }
 
+/**
+ * React hook for accessing the current user's account with selective data extraction and custom equality checking.
+ *
+ * This hook extends `useAccount` by allowing you to select only specific parts of the account data
+ * through a selector function, which helps reduce unnecessary re-renders by narrowing down the
+ * returned data. Additionally, you can provide a custom equality function to further optimize
+ * performance by controlling when the component should re-render based on the selected data.
+ *
+ * The hook automatically handles the subscription lifecycle and supports deep loading of nested
+ * CoValues through resolve queries, just like `useAccount`.
+ *
+ * @returns The result of the selector function applied to the loaded account data
+ *
+ * @example
+ * ```tsx
+ * // Select only specific fields to reduce re-renders
+ * const MyAppAccount = co.account({
+ *   profile: co.profile(),
+ *   root: co.map({
+ *     name: z.string(),
+ *     email: z.string(),
+ *     lastLogin: z.date(),
+ *   }),
+ * });
+ *
+ * function UserProfile({ accountId }: { accountId: string }) {
+ *   // Only re-render when the profile name changes, not other fields
+ *   const profileName = useAccountWithSelector(
+ *     MyAppAccount,
+ *     {
+ *       resolve: {
+ *         profile: true,
+ *         root: true,
+ *       },
+ *       select: (account) => account?.profile?.name ?? "Loading...",
+ *     }
+ *   );
+ *
+ *   return <h1>{profileName}</h1>;
+ * }
+ * ```
+ *
+ * For more examples, see the [subscription and deep loading](https://jazz.tools/docs/react/using-covalues/subscription-and-loading) documentation.
+ */
+export function useAccountWithSelector<
+  A extends AccountClass<Account> | AnyAccountSchema,
+  TSelectorReturn,
+  R extends ResolveQuery<A> = true,
+>(
+  /** The account schema to use. Defaults to the base Account schema */
+  AccountSchema: A = Account as unknown as A,
+  /** Configuration for the subscription and selection */
+  options: {
+    /** Resolve query to specify which nested CoValues to load from the account */
+    resolve?: ResolveQueryStrict<A, R>;
+    /** Select which value to return from the account data */
+    select: (account: Loaded<A, R> | undefined | null) => TSelectorReturn;
+    /** Equality function to determine if the selected value has changed, defaults to `Object.is` */
+    equalityFn?: (a: TSelectorReturn, b: TSelectorReturn) => boolean;
+  },
+): TSelectorReturn {
+  const subscription = useAccountSubscription(AccountSchema, options);
+
+  return useSyncExternalStoreWithSelector<
+    Loaded<A, R> | undefined | null,
+    TSelectorReturn
+  >(
+    React.useCallback(
+      (callback) => {
+        if (!subscription) {
+          return () => {};
+        }
+
+        return subscription.subscribe(callback);
+      },
+      [subscription],
+    ),
+    () => (subscription ? subscription.getCurrentValue() : null),
+    () => (subscription ? subscription.getCurrentValue() : null),
+    options.select,
+    options.equalityFn ?? Object.is,
+  );
+}
+
 export function experimental_useInboxSender<
   I extends CoValue,
   O extends CoValue | undefined,