jazz-tools 0.18.37 → 0.19.0

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

@@ -1,15 +1,21 @@
 // @vitest-environment happy-dom
 
-import { Group, RefsToResolve, co, z } from "jazz-tools";
+import { CoValueLoadingState, Group, RefsToResolve, co, z } from "jazz-tools";
+import { assertLoaded } from "jazz-tools/testing";
 import { assert, beforeEach, describe, expect, it } from "vitest";
-import { useAccount, useJazzContextManager } from "../hooks.js";
+import {
+  useAccount,
+  useAgent,
+  useJazzContextManager,
+  useLogOut,
+} from "../hooks.js";
 import { useIsAuthenticated } from "../index.js";
 import {
   createJazzTestAccount,
   createJazzTestGuest,
   setupJazzTestSync,
 } from "../testing.js";
-import { act, renderHook } from "./testUtils.js";
+import { act, renderHook, waitFor } from "./testUtils.js";
 
 beforeEach(async () => {
   await setupJazzTestSync();
@@ -23,7 +29,7 @@ describe("useAccount", () => {
       account,
     });
 
-    expect(result.current?.me).toEqual(account);
+    expect(result.current).toEqual(account);
   });
 
   it("should load nested values if requested", async () => {
@@ -48,83 +54,21 @@ describe("useAccount", () => {
 
     const { result } = renderHook(
       () =>
-        useAccount<typeof AccountSchema, RefsToResolve<{ root: true }>>(
-          AccountSchema,
-          {
-            resolve: {
-              root: true,
-            },
+        useAccount(AccountSchema, {
+          resolve: {
+            root: true,
           },
-        ),
-      {
-        account,
-      },
-    );
-
-    expect(result.current?.me?.root?.value).toBe("123");
-  });
-
-  it("should be in sync with useIsAuthenticated when logOut (from useAccount.logOut) is called", async () => {
-    const account = await createJazzTestAccount({});
-
-    const accounts: string[] = [];
-    const updates: { isAuthenticated: boolean; accountIndex: number }[] = [];
-
-    const { result } = renderHook(
-      () => {
-        const isAuthenticated = useIsAuthenticated();
-        const account = useAccount();
-
-        if (account.me) {
-          if (!accounts.includes(account.me.$jazz.id)) {
-            accounts.push(account.me.$jazz.id);
-          }
-
-          updates.push({
-            isAuthenticated,
-            accountIndex: accounts.indexOf(account.me.$jazz.id),
-          });
-        }
-
-        return { isAuthenticated, account };
-      },
+        }),
       {
         account,
-        isAuthenticated: true,
       },
     );
 
-    expect(result.current?.isAuthenticated).toBe(true);
-    expect(result.current?.account?.me).toBeDefined();
-
-    const id = result.current?.account?.me?.$jazz.id;
-
-    await act(async () => {
-      await result.current?.account?.logOut();
-    });
-
-    expect(result.current?.isAuthenticated).toBe(false);
-    expect(result.current?.account?.me?.$jazz.id).not.toBe(id);
-
-    expect(updates).toMatchInlineSnapshot(`
-      [
-        {
-          "accountIndex": 0,
-          "isAuthenticated": true,
-        },
-        {
-          "accountIndex": 0,
-          "isAuthenticated": false,
-        },
-        {
-          "accountIndex": 1,
-          "isAuthenticated": false,
-        },
-      ]
-    `);
+    assertLoaded(result.current);
+    expect(result.current.root.value).toBe("123");
   });
 
-  it("should be in sync with useIsAuthenticated when logOut (from useLogOut) is called", async () => {
+  it("should be in sync with useIsAuthenticated when logOut is called", async () => {
     const account = await createJazzTestAccount({});
 
     const accounts: string[] = [];
@@ -134,19 +78,20 @@ describe("useAccount", () => {
       () => {
         const isAuthenticated = useIsAuthenticated();
         const account = useAccount();
+        const logOut = useLogOut();
 
-        if (account.me) {
-          if (!accounts.includes(account.me.$jazz.id)) {
-            accounts.push(account.me.$jazz.id);
+        if (account) {
+          if (!accounts.includes(account.$jazz.id)) {
+            accounts.push(account.$jazz.id);
           }
 
           updates.push({
             isAuthenticated,
-            accountIndex: accounts.indexOf(account.me.$jazz.id),
+            accountIndex: accounts.indexOf(account.$jazz.id),
           });
         }
 
-        return { isAuthenticated, account };
+        return { isAuthenticated, account, logOut };
       },
       {
         account,
@@ -155,16 +100,16 @@ describe("useAccount", () => {
     );
 
     expect(result.current?.isAuthenticated).toBe(true);
-    expect(result.current?.account?.me).toBeDefined();
+    expect(result.current?.account).toBeDefined();
 
-    const id = result.current?.account?.me?.$jazz.id;
+    const id = result.current?.account.$jazz.id;
 
     await act(async () => {
-      await result.current?.account?.logOut();
+      await result.current?.logOut();
     });
 
     expect(result.current?.isAuthenticated).toBe(false);
-    expect(result.current?.account?.me?.$jazz.id).not.toBe(id);
+    expect(result.current?.account?.$jazz.id).not.toBe(id);
 
     expect(updates).toMatchInlineSnapshot(`
       [
@@ -197,14 +142,14 @@ describe("useAccount", () => {
         const account = useAccount();
         const contextManager = useJazzContextManager();
 
-        if (account.me) {
-          if (!accounts.includes(account.me.$jazz.id)) {
-            accounts.push(account.me.$jazz.id);
+        if (account) {
+          if (!accounts.includes(account.$jazz.id)) {
+            accounts.push(account.$jazz.id);
           }
 
           updates.push({
             isAuthenticated,
-            accountIndex: accounts.indexOf(account.me.$jazz.id),
+            accountIndex: accounts.indexOf(account.$jazz.id),
           });
         }
 
@@ -217,9 +162,9 @@ describe("useAccount", () => {
     );
 
     expect(result.current?.isAuthenticated).toBe(false);
-    expect(result.current?.account?.me).toBeDefined();
+    expect(result.current?.account).toBeDefined();
 
-    const id = result.current?.account?.me?.$jazz.id;
+    const id = result.current?.account.$jazz.id;
 
     await act(async () => {
       await result.current?.contextManager?.authenticate({
@@ -230,7 +175,7 @@ describe("useAccount", () => {
     });
 
     expect(result.current?.isAuthenticated).toBe(true);
-    expect(result.current?.account?.me?.$jazz.id).not.toBe(id);
+    expect(result.current?.account.$jazz.id).not.toBe(id);
 
     expect(updates).toMatchInlineSnapshot(`
       [
@@ -265,21 +210,62 @@ describe("useAccount", () => {
     const account = await createJazzTestGuest();
 
     const { result } = renderHook(
-      () =>
-        useAccount(AccountSchema, {
+      () => {
+        const me = useAccount(AccountSchema, {
           resolve: {
             root: true,
           },
-        }),
+        });
+        const agent = useAgent();
+        return { account: me, agent };
+      },
       {
         account,
       },
     );
 
-    expect(result.current.me).toBe(null);
+    expect(result.current.account.$jazz.loadingState).toBe(
+      CoValueLoadingState.UNAVAILABLE,
+    );
     expect(result.current.agent).toBe(account.guest);
   });
 
+  it("should use the schema's resolve query if no resolve query is provided", async () => {
+    const AccountRoot = co.map({
+      name: co.plainText(),
+    });
+
+    const AccountSchema = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration((account, creationProps) => {
+        if (!account.$jazz.refs.root) {
+          account.$jazz.set("root", { name: "John Doe" });
+        }
+      })
+      .resolved({
+        root: { name: true },
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema,
+      isCurrentActiveAccount: true,
+    });
+
+    const { result } = renderHook(() => useAccount(AccountSchema), {
+      account,
+    });
+
+    await waitFor(() => {
+      expect(result.current).not.toBeNull();
+    });
+
+    assertLoaded(result.current);
+    expect(result.current.root.name.toUpperCase()).toBe("JOHN DOE");
+  });
+
   it("should work with branches - create branch, edit and merge", async () => {
     const AccountRoot = co.map({
       name: z.string(),
@@ -342,11 +328,11 @@ describe("useAccount", () => {
     const branchAccount = result.current.branchAccount;
     const mainAccount = result.current.mainAccount;
 
-    assert(branchAccount?.me);
-    assert(mainAccount?.me);
+    assertLoaded(branchAccount);
+    assertLoaded(mainAccount);
 
     act(() => {
-      branchAccount.me?.root.$jazz.applyDiff({
+      branchAccount.root.$jazz.applyDiff({
         name: "John Smith",
         age: 31,
         email: "john.smith@example.com",
@@ -354,21 +340,21 @@ describe("useAccount", () => {
     });
 
     // Verify the branch has the changes
-    expect(branchAccount.me.root?.name).toBe("John Smith");
-    expect(branchAccount.me.root?.age).toBe(31);
-    expect(branchAccount.me.root?.email).toBe("john.smith@example.com");
+    expect(branchAccount.root.name).toBe("John Smith");
+    expect(branchAccount.root.age).toBe(31);
+    expect(branchAccount.root.email).toBe("john.smith@example.com");
 
     // Verify the original is unchanged
-    expect(mainAccount.me.root?.name).toBe("John Doe");
-    expect(mainAccount.me.root?.age).toBe(30);
-    expect(mainAccount.me.root?.email).toBe("john@example.com");
+    expect(mainAccount.root.name).toBe("John Doe");
+    expect(mainAccount.root.age).toBe(30);
+    expect(mainAccount.root.email).toBe("john@example.com");
 
     // Merge the branch back
-    branchAccount.me.root.$jazz.unstable_merge();
+    branchAccount.root.$jazz.unstable_merge();
 
     // Verify the original now has the merged changes
-    expect(mainAccount.me.root?.name).toBe("John Smith");
-    expect(mainAccount.me.root?.age).toBe(31);
-    expect(mainAccount.me.root?.email).toBe("john.smith@example.com");
+    expect(mainAccount.root.name).toBe("John Smith");
+    expect(mainAccount.root.age).toBe(31);
+    expect(mainAccount.root.email).toBe("john.smith@example.com");
   });
 });

package/src/react-core/tests/{useCoStateWithSelector.test.ts → useCoState.selector.test.ts}

@@ -3,7 +3,7 @@
 import { cojsonInternals } from "cojson";
 import { Account, co, Loaded, z } from "jazz-tools";
 import { beforeEach, describe, expect, expectTypeOf, it } from "vitest";
-import { useCoStateWithSelector } from "../index.js";
+import { useCoState } from "../index.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { renderHook, waitFor } from "./testUtils.js";
 import { useRef } from "react";
@@ -28,7 +28,7 @@ const useRenderCount = <T>(hook: () => T) => {
   };
 };
 
-describe("useCoStateWithSelector", () => {
+describe("useCoState", () => {
   it("should not re-render when a nested coValue is updated and not selected", async () => {
     const TestMap = co.map({
       value: z.string(),
@@ -46,11 +46,16 @@ describe("useCoStateWithSelector", () => {
 
     const { result } = renderHook(() =>
       useRenderCount(() =>
-        useCoStateWithSelector(TestMap, map.$jazz.id, {
+        useCoState(TestMap, map.$jazz.id, {
           resolve: {
             nested: true,
           },
-          select: (v) => v?.value,
+          select: (v) => {
+            if (!v.$isLoaded) {
+              return undefined;
+            }
+            return v.value;
+          },
         }),
       ),
     );
@@ -85,11 +90,16 @@ describe("useCoStateWithSelector", () => {
 
     const { result } = renderHook(() =>
       useRenderCount(() =>
-        useCoStateWithSelector(TestMap, map.$jazz.id, {
+        useCoState(TestMap, map.$jazz.id, {
           resolve: {
             nested: true,
           },
-          select: (v) => v?.nested?.value,
+          select: (v) => {
+            if (!v.$isLoaded) {
+              return undefined;
+            }
+            return v.nested?.value;
+          },
         }),
       ),
     );
@@ -128,11 +138,16 @@ describe("useCoStateWithSelector", () => {
 
     const { result } = renderHook(() =>
       useRenderCount(() =>
-        useCoStateWithSelector(TestMap, map.$jazz.id, {
+        useCoState(TestMap, map.$jazz.id, {
           resolve: {
             nested: true,
           },
-          select: (v) => v?.nested?.value,
+          select: (v) => {
+            if (!v.$isLoaded) {
+              return undefined;
+            }
+            return v.nested?.value;
+          },
           equalityFn: () => true,
         }),
       ),