jazz-tools 0.17.14 → 0.18.1

package/src/tools/tests/ContextManager.test.ts

@@ -125,15 +125,15 @@ describe("ContextManager", () => {
     await manager.createContext({});
 
     const credentials = {
-      accountID: account.id,
-      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       provider: "test",
     };
 
     // Authenticate with those credentials
     await manager.authenticate(credentials);
 
-    expect(getCurrentValue().me.id).toBe(credentials.accountID);
+    expect(getCurrentValue().me.$jazz.id).toBe(credentials.accountID);
   });
 
   test("handles race conditions on the context creation", async () => {
@@ -142,15 +142,15 @@ describe("ContextManager", () => {
     manager.createContext({});
 
     const credentials = {
-      accountID: account.id,
-      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       provider: "test",
     };
 
     // Authenticate without waiting for the previous context to be created
     await manager.authenticate(credentials);
 
-    expect(getCurrentValue().me.id).toBe(credentials.accountID);
+    expect(getCurrentValue().me.$jazz.id).toBe(credentials.accountID);
   });
 
   test("calls onLogOut callback when logging out", async () => {
@@ -205,8 +205,8 @@ describe("ContextManager", () => {
 
     // Authenticate with credentials
     await manager.authenticate({
-      accountID: account.id,
-      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       provider: "test",
     });
 
@@ -219,8 +219,8 @@ describe("ContextManager", () => {
     const account = await createJazzTestAccount();
 
     await manager.getAuthSecretStorage().set({
-      accountID: account.id,
-      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       provider: "test",
     });
 
@@ -229,8 +229,8 @@ describe("ContextManager", () => {
 
     // Authenticate with same credentials
     await manager.authenticate({
-      accountID: account.id,
-      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       provider: "test",
     });
 
@@ -256,11 +256,14 @@ describe("ContextManager", () => {
         profile: co.profile(),
       })
       .withMigration(async (account) => {
-        account.root = AccountRoot.create(
-          {
-            value: "Hello",
-          },
-          Group.create(this).makePublic(),
+        account.$jazz.set(
+          "root",
+          AccountRoot.create(
+            {
+              value: "Hello",
+            },
+            Group.create(this).makePublic(),
+          ),
         );
       });
 
@@ -272,15 +275,16 @@ describe("ContextManager", () => {
       AccountSchema: coValueClassFromCoValueClassOrSchema(CustomAccount),
       storage: dbFilename,
       onAnonymousAccountDiscarded: async (anonymousAccount) => {
-        const anonymousAccountWithRoot = await anonymousAccount.ensureLoaded({
-          resolve: { root: true },
-        });
+        const anonymousAccountWithRoot =
+          await anonymousAccount.$jazz.ensureLoaded({
+            resolve: { root: true },
+          });
 
-        const me = await CustomAccount.getMe().ensureLoaded({
+        const me = await CustomAccount.getMe().$jazz.ensureLoaded({
           resolve: { root: true },
         });
 
-        me.root.transferredRoot = anonymousAccountWithRoot.root;
+        me.root.$jazz.set("transferredRoot", anonymousAccountWithRoot.root);
       },
     });
 
@@ -295,15 +299,15 @@ describe("ContextManager", () => {
     ).me;
 
     await customManager.authenticate({
-      accountID: account.id,
-      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       provider: "test",
     });
 
     // The storage should be closed and set to undefined
     expect(prevContextNode.storage).toBeUndefined();
 
-    const me = await CustomAccount.getMe().ensureLoaded({
+    const me = await CustomAccount.getMe().$jazz.ensureLoaded({
       resolve: { root: { transferredRoot: true } },
     });
 
@@ -322,11 +326,11 @@ describe("ContextManager", () => {
         root: AccountRoot,
         profile: co.profile(),
       })
-      .withMigration(async (account) => {
-        account.root = AccountRoot.create({
+      .withMigration(async (account: Account) => {
+        account.$jazz.set("root", {
           value: "Hello",
         });
-        lastRootId = account.root.id;
+        lastRootId = account.root!.$jazz.id;
       });
 
     const customManager = new TestJazzContextManager<
@@ -345,16 +349,16 @@ describe("ContextManager", () => {
     ).me;
 
     await customManager.authenticate({
-      accountID: account.id,
-      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       provider: "test",
     });
 
-    const me = await CustomAccount.getMe().ensureLoaded({
+    const me = await CustomAccount.getMe().$jazz.ensureLoaded({
       resolve: { root: true },
     });
 
-    expect(me.root.id).toBe(lastRootId);
+    expect(me.root.$jazz.id).toBe(lastRootId);
   });
 
   test("the migration should be applied correctly on existing accounts (2)", async () => {
@@ -368,16 +372,19 @@ describe("ContextManager", () => {
         profile: co.profile(),
       })
       .withMigration(async (account) => {
-        if (account.root === undefined) {
-          account.root = AccountRoot.create({
-            value: 1,
-          });
+        if (!account.$jazz.has("root")) {
+          account.$jazz.set(
+            "root",
+            AccountRoot.create({
+              value: 1,
+            }),
+          );
         } else {
-          const { root } = await account.ensureLoaded({
+          const { root } = await account.$jazz.ensureLoaded({
             resolve: { root: true },
           });
 
-          root.value = 2;
+          root.$jazz.set("value", 2);
         }
       });
     const customManager = new TestJazzContextManager<
@@ -396,12 +403,12 @@ describe("ContextManager", () => {
     ).me;
 
     await customManager.authenticate({
-      accountID: account.id,
-      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       provider: "test",
     });
 
-    const me = await CustomAccount.getMe().ensureLoaded({
+    const me = await CustomAccount.getMe().$jazz.ensureLoaded({
       resolve: { root: true },
     });
 
@@ -422,23 +429,27 @@ describe("ContextManager", () => {
         profile: co.profile(),
       })
       .withMigration(async (account) => {
-        if (account.root === undefined) {
-          account.root = AccountRoot.create({
-            value: "Hello",
-          });
+        if (!account.$jazz.has("root")) {
+          account.$jazz.set(
+            "root",
+            AccountRoot.create({
+              value: "Hello",
+            }),
+          );
         }
       });
 
     const onAnonymousAccountDiscarded = async (
       anonymousAccount: Loaded<typeof CustomAccount, { root: true }>,
     ) => {
-      const anonymousAccountWithRoot = await anonymousAccount.ensureLoaded({
-        resolve: {
-          root: true,
-        },
-      });
+      const anonymousAccountWithRoot =
+        await anonymousAccount.$jazz.ensureLoaded({
+          resolve: {
+            root: true,
+          },
+        });
 
-      const meWithRoot = await CustomAccount.getMe().ensureLoaded({
+      const meWithRoot = await CustomAccount.getMe().$jazz.ensureLoaded({
         resolve: {
           root: true,
         },
@@ -446,9 +457,9 @@ describe("ContextManager", () => {
 
       const rootToTransfer = anonymousAccountWithRoot.root;
 
-      await rootToTransfer._owner.castAs(Group).addMember(meWithRoot, "admin");
+      await rootToTransfer.$jazz.owner.addMember(meWithRoot, "admin");
 
-      meWithRoot.root.transferredRoot = rootToTransfer;
+      meWithRoot.root.$jazz.set("transferredRoot", rootToTransfer);
     };
 
     const customManager = new TestJazzContextManager<
@@ -467,12 +478,12 @@ describe("ContextManager", () => {
     });
 
     await customManager.authenticate({
-      accountID: account.id,
-      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       provider: "test",
     });
 
-    const me = await CustomAccount.getMe().ensureLoaded({
+    const me = await CustomAccount.getMe().$jazz.ensureLoaded({
       resolve: {
         root: true,
       },
@@ -491,7 +502,7 @@ describe("ContextManager", () => {
     expect(accountId).toBeDefined();
     const context = getCurrentValue();
     expect(context.me.profile?.name).toBe("Test User");
-    expect(context.me.id).toBe(accountId);
+    expect(context.me.$jazz.id).toBe(accountId);
   });
 
   test("calls onAnonymousAccountDiscarded when registering from anonymous user", async () => {
@@ -510,8 +521,8 @@ describe("ContextManager", () => {
     const account = await createJazzTestAccount();
 
     await manager.getAuthSecretStorage().set({
-      accountID: account.id,
-      accountSecret: account._raw.core.node.getCurrentAgent().agentSecret,
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       provider: "test",
     });
 

package/src/tools/tests/PassphraseAuth.test.ts

@@ -151,7 +151,7 @@ describe("PassphraseAuth", () => {
       await passphraseAuth.signUp(testName);
 
       // Verify the account name was set
-      const { profile } = await account.ensureLoaded({
+      const { profile } = await account.$jazz.ensureLoaded({
         resolve: {
           profile: true,
         },
@@ -315,7 +315,7 @@ describe("PassphraseAuth with TestJazzContextManager", () => {
       const context = contextManager.getCurrentValue();
 
       assert(context && "me" in context);
-      expect(context.me.id).toBe(accountId);
+      expect(context.me.$jazz.id).toBe(accountId);
       expect(context.me.profile?.name).toBe("Test User");
 
       expect(authSecretStorage.isAuthenticated).toBe(true);

package/src/tools/tests/account.test.ts

@@ -23,7 +23,7 @@ test("waitForAllCoValuesSync should resolve when all the values are synced", asy
     TestMap.create({ name: "Alice" }, { owner: clientAccount }),
   );
 
-  await clientAccount.waitForAllCoValuesSync({
+  await clientAccount.$jazz.waitForAllCoValuesSync({
     timeout: 1000,
   });
 
@@ -31,7 +31,7 @@ test("waitForAllCoValuesSync should resolve when all the values are synced", asy
   clientNode.gracefulShutdown();
 
   for (const map of maps) {
-    const loadedMap = await serverNode.load(map._raw.id);
+    const loadedMap = await serverNode.load(map.$jazz.raw.id);
     expect(loadedMap).not.toBe("unavailable");
   }
 });
@@ -39,12 +39,12 @@ test("waitForAllCoValuesSync should resolve when all the values are synced", asy
 test("waitForSync should resolve when the value is uploaded", async () => {
   const { clientNode, serverNode, clientAccount } = await setupTwoNodes();
 
-  await clientAccount.waitForSync({ timeout: 1000 });
+  await clientAccount.$jazz.waitForSync({ timeout: 1000 });
 
   // Killing the client node so the serverNode can't load the map from it
   clientNode.gracefulShutdown();
 
-  const loadedAccount = await serverNode.load(clientAccount._raw.id);
+  const loadedAccount = await serverNode.load(clientAccount.$jazz.raw.id);
 
   expect(loadedAccount).not.toBe("unavailable");
 });
@@ -86,11 +86,11 @@ test("Me gets updated correctly when creating a new account as active", async ()
 
 test("accounts should sync correctly", async () => {
   const account = await createJazzTestAccount({ isCurrentActiveAccount: true });
-  account.profile!.name = "test 1";
+  account.profile!.$jazz.set("name", "test 1");
   const otherAccount = await createJazzTestAccount({
     isCurrentActiveAccount: true,
   });
-  otherAccount.profile!.name = "test 2";
+  otherAccount.profile!.$jazz.set("name", "test 2");
 
   await linkAccounts(account, otherAccount);
 
@@ -111,7 +111,7 @@ test("loading accounts should work", async () => {
 
   const otherAccount = await createJazzTestAccount();
 
-  const loadedAccount = await Account.load(account.id, {
+  const loadedAccount = await Account.load(account.$jazz.id, {
     loadAs: otherAccount,
     resolve: {
       profile: true,
@@ -129,7 +129,7 @@ test("loading raw accounts should work", async () => {
     },
   });
 
-  const loadedAccount = await Account.load(account.id, {
+  const loadedAccount = await Account.load(account.$jazz.id, {
     loadAs: account,
   });
 
@@ -180,21 +180,24 @@ test("should support recursive props on co.profile", async () => {
       if (me.profile === undefined) {
         const group = Group.create({ owner: me });
         group.addMember("everyone", "reader");
-        me.profile = User.create(
-          {
-            name: "test 1",
-            created: new Date(),
-            updated: new Date(),
-            anonymous: false,
-            following: co.list(User).create([], group),
-            followers: co.list(User).create([], group),
-          },
-          group,
+        me.$jazz.set(
+          "profile",
+          User.create(
+            {
+              name: "test 1",
+              created: new Date(),
+              updated: new Date(),
+              anonymous: false,
+              following: co.list(User).create([], group),
+              followers: co.list(User).create([], group),
+            },
+            group,
+          ),
         );
       }
 
       if (me.root === undefined) {
-        me.root = co.map({}).create({});
+        me.$jazz.set("root", {});
       }
     });
 
@@ -211,64 +214,182 @@ test("should support recursive props on co.profile", async () => {
   expect(account.profile.followers.length).toBe(0);
 });
 
-test("root and profile should be trusting by default", async () => {
-  const AccountSchema = co
-    .account({
-      profile: co.profile(),
-      root: co.map({
-        name: z.string(),
-      }),
-    })
-    .withMigration((me, creationProps) => {
-      const group = Group.create({ owner: me }).makePublic();
+test("cannot update account profile properties directly", async () => {
+  const account = await createJazzTestAccount({
+    creationProps: {
+      name: "test 1",
+    },
+  });
 
-      if (me.profile === undefined) {
-        me.profile = co.profile().create(
-          {
-            name: creationProps?.name ?? "Anonymous",
-          },
-          group,
-        );
-      }
+  assert(account.profile);
 
-      if (me.root === undefined) {
-        me.root = co
-          .map({
-            name: z.string(),
-          })
-          .create(
-            {
-              name: creationProps?.name ?? "Anonymous",
-            },
-            group,
+  // @ts-expect-error - cannot update profile properties directly
+  expect(() => (account.profile.name = "test 2")).toThrow(
+    "Cannot update a CoMap directly. Use `$jazz.set` instead.",
+  );
+  account.profile.$jazz.set("name", "test 3");
+  expect(account.profile.name).toBe("test 3");
+});
+
+describe("root and profile", () => {
+  test("root and profile should be trusting by default", async () => {
+    const AccountSchema = co
+      .account({
+        profile: co.profile(),
+        root: co.map({
+          name: z.string(),
+        }),
+      })
+      .withMigration((me, creationProps) => {
+        const group = Group.create({ owner: me }).makePublic();
+
+        if (me.profile === undefined) {
+          me.$jazz.set(
+            "profile",
+            co.profile().create(
+              {
+                name: creationProps?.name ?? "Anonymous",
+              },
+              group,
+            ),
           );
-      }
+        }
+
+        if (me.root === undefined) {
+          me.$jazz.set(
+            "root",
+            co
+              .map({
+                name: z.string(),
+              })
+              .create(
+                {
+                  name: creationProps?.name ?? "Anonymous",
+                },
+                group,
+              ),
+          );
+        }
+      });
+
+    const bob = await createJazzTestAccount({
+      AccountSchema,
+      creationProps: {
+        name: "Bob",
+      },
     });
 
-  const bob = await createJazzTestAccount({
-    AccountSchema,
-    creationProps: {
-      name: "Bob",
-    },
+    const alice = await createJazzTestAccount({
+      AccountSchema,
+      creationProps: {
+        name: "Alice",
+      },
+    });
+
+    const bobAccountLoadedFromAlice = await AccountSchema.load(bob.$jazz.id, {
+      loadAs: alice,
+      resolve: {
+        profile: true,
+        root: true,
+      },
+    });
+
+    assert(bobAccountLoadedFromAlice);
+
+    expect(bobAccountLoadedFromAlice.profile.name).toBe("Bob");
+    expect(bobAccountLoadedFromAlice.root.name).toBe("Bob");
   });
 
-  const alice = await createJazzTestAccount({
-    AccountSchema,
-    creationProps: {
-      name: "Alice",
-    },
+  test("can be initialized using JSON objects", async () => {
+    const Avatar = co.map({
+      url: z.string(),
+    });
+    const CustomProfile = co.profile({
+      avatar: Avatar,
+    });
+    const CustomRoot = co.map({
+      name: z.string(),
+    });
+    const AccountSchema = co
+      .account({
+        profile: CustomProfile,
+        root: CustomRoot,
+      })
+      .withMigration((me, creationProps) => {
+        if (me.profile === undefined) {
+          me.$jazz.set("profile", {
+            name: creationProps?.name ?? "Anonymous",
+            avatar: {
+              url: "https://example.com/avatar.png",
+            },
+          });
+        }
+
+        if (me.root === undefined) {
+          me.$jazz.set("root", { name: creationProps?.name ?? "Anonymous" });
+        }
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema,
+      creationProps: {
+        name: "test 1",
+      },
+    });
+
+    expect(account.profile.name).toBe("test 1");
+    expect(account.profile.avatar.url).toBe("https://example.com/avatar.png");
+    expect(account.root.name).toBe("test 1");
   });
+});
 
-  const bobAccountLoadedFromAlice = await AccountSchema.load(bob.id, {
-    loadAs: alice,
-    resolve: {
-      profile: true,
-      root: true,
-    },
+describe("account.$jazz.has", () => {
+  test("should return true if the key is defined", async () => {
+    const account = await createJazzTestAccount({
+      creationProps: { name: "John" },
+    });
+
+    expect(account.$jazz.has("profile")).toBe(true);
+    expect(account.$jazz.has("root")).toBe(false);
   });
 
-  assert(bobAccountLoadedFromAlice);
+  test("should work as migration check", async () => {
+    const CustomProfile = co.profile({
+      name: z.string(),
+      email: z.string().optional(),
+    });
 
-  expect(bobAccountLoadedFromAlice.profile.name).toBe("Bob");
-  expect(bobAccountLoadedFromAlice.root.name).toBe("Bob");
+    const CustomRoot = co.map({
+      settings: z.string(),
+    });
+
+    const CustomAccount = co
+      .account({
+        profile: CustomProfile,
+        root: CustomRoot,
+      })
+      .withMigration((me, creationProps) => {
+        if (!me.$jazz.has("profile")) {
+          me.$jazz.set("profile", {
+            name: creationProps?.name ?? "Anonymous",
+            email: "test@example.com",
+          });
+        }
+
+        if (!me.$jazz.has("root")) {
+          me.$jazz.set("root", { settings: "default" });
+        }
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema: CustomAccount,
+      creationProps: { name: "Custom User" },
+    });
+
+    expect(account.$jazz.has("profile")).toBe(true);
+    expect(account.$jazz.has("root")).toBe(true);
+
+    expect(account.profile.email).toBe("test@example.com");
+    expect(account.root.settings).toBe("default");
+  });
 });

package/src/tools/tests/coDiscriminatedUnion.test-d.ts

@@ -29,9 +29,12 @@ describe("co.discriminatedUnion", () => {
       }),
     });
 
-    person.pet = Cat.create({
-      type: "cat",
-    });
+    person.$jazz.set(
+      "pet",
+      Cat.create({
+        type: "cat",
+      }),
+    );
 
     type ExpectedType = {
       pet: Loaded<typeof Dog> | Loaded<typeof Cat>;
@@ -67,9 +70,12 @@ describe("co.discriminatedUnion", () => {
       }),
     });
 
-    pallino.friend = Cat.create({
-      type: "cat",
-    });
+    pallino.$jazz.set(
+      "friend",
+      Cat.create({
+        type: "cat",
+      }),
+    );
 
     type ExpectedType = {
       friend: Loaded<typeof Dog> | Loaded<typeof Cat> | undefined;