jazz-tools 0.17.14 → 0.18.1

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

@@ -14,6 +14,7 @@ import { Group, co, subscribeToCoValue, z } from "../exports.js";
 import { Account } from "../index.js";
 import {
   Loaded,
+  TypeSym,
   activeAccountContext,
   coValueClassFromCoValueClassOrSchema,
 } from "../internal.js";
@@ -69,7 +70,7 @@ describe("CoMap", async () => {
       expect(john.color).toEqual("red");
       expect(john._height).toEqual(10);
       expect(john.birthday).toEqual(birthday);
-      expect(john._raw.get("birthday")).toEqual(birthday.toISOString());
+      expect(john.$jazz.raw.get("birthday")).toEqual(birthday.toISOString());
       expect(Object.keys(john)).toEqual([
         "color",
         "_height",
@@ -93,6 +94,17 @@ describe("CoMap", async () => {
       expect("age" in john).toEqual(false);
     });
 
+    test("internal properties are not enumerable", () => {
+      const Person = co.map({
+        name: z.string(),
+      });
+
+      const person = Person.create({ name: "John" });
+
+      expect(Object.keys(person)).toEqual(["name"]);
+      expect(person).toEqual({ name: "John" });
+    });
+
     test("create a CoMap with an account as owner", () => {
       const Person = co.map({
         name: z.string(),
@@ -101,7 +113,7 @@ describe("CoMap", async () => {
       const john = Person.create({ name: "John" }, Account.getMe());
 
       expect(john.name).toEqual("John");
-      expect(john._raw.get("name")).toEqual("John");
+      expect(john.$jazz.raw.get("name")).toEqual("John");
     });
 
     test("create a CoMap with a group as owner", () => {
@@ -112,7 +124,7 @@ describe("CoMap", async () => {
       const john = Person.create({ name: "John" }, Group.create());
 
       expect(john.name).toEqual("John");
-      expect(john._raw.get("name")).toEqual("John");
+      expect(john.$jazz.raw.get("name")).toEqual("John");
     });
 
     test("Empty schema", () => {
@@ -151,7 +163,7 @@ describe("CoMap", async () => {
         type: z.literal("cat"),
         name: z.string(),
       });
-
+      const Pet = co.discriminatedUnion("type", [Dog, Cat]);
       const Person = co.map({
         name: co.plainText(),
         bio: co.richText(),
@@ -160,7 +172,8 @@ describe("CoMap", async () => {
           return co.list(Person);
         },
         reactions: co.feed(co.plainText()),
-        pet: co.discriminatedUnion("type", [Dog, Cat]),
+        pet: Pet,
+        pets: co.record(z.string(), Pet),
       });
 
       let person: ReturnType<typeof Person.create>;
@@ -178,10 +191,17 @@ describe("CoMap", async () => {
               friends: [],
               reactions: [],
               pet: { type: "dog", name: "Fido" },
+              pets: {
+                dog: { type: "dog", name: "Fido" },
+              },
             },
           ],
           reactions: ["👎", "👍"],
           pet: { type: "cat", name: "Whiskers" },
+          pets: {
+            dog: { type: "dog", name: "Rex" },
+            cat: { type: "cat", name: "Whiskers" },
+          },
         });
       });
 
@@ -198,19 +218,25 @@ describe("CoMap", async () => {
         expect(person.friends[0]?.friends.length).toEqual(0);
         expect(person.reactions.byMe?.value?.toString()).toEqual("👍");
         expect(person.pet.name).toEqual("Whiskers");
+        expect(person.pets.dog?.name).toEqual("Rex");
+        expect(person.pets.cat?.name).toEqual("Whiskers");
       });
 
       it("creates a group for each new CoValue that is a child of the referencing CoValue's owner", () => {
         for (const value of Object.values(person)) {
           expect(
-            value._owner.getParentGroups().map((group: Group) => group.id),
-          ).toContain(person._owner.id);
+            value.$jazz.owner
+              .getParentGroups()
+              .map((group: Group) => group.$jazz.id),
+          ).toContain(person.$jazz.owner.$jazz.id);
         }
         const friend = person.friends[0]!;
         for (const value of Object.values(friend)) {
           expect(
-            value._owner.getParentGroups().map((group: Group) => group.id),
-          ).toContain(friend._owner.id);
+            value.$jazz.owner
+              .getParentGroups()
+              .map((group: Group) => group.$jazz.id),
+          ).toContain(friend.$jazz.owner.$jazz.id);
         }
       });
 
@@ -228,8 +254,10 @@ describe("CoMap", async () => {
           const map = Schema.create({ text: "Hello" }, parentGroup);
 
           expect(
-            map.text._owner.getParentGroups().map((group: Group) => group.id),
-          ).toContain(parentGroup.id);
+            map.text.$jazz.owner
+              .getParentGroups()
+              .map((group: Group) => group.$jazz.id),
+          ).toContain(parentGroup.$jazz.id);
         });
       });
     });
@@ -253,6 +281,16 @@ describe("CoMap", async () => {
       expect(person.friend?.age).toEqual(21);
     });
 
+    test("JSON.stringify should not include internal properties", () => {
+      const Person = co.map({
+        name: z.string(),
+      });
+
+      const person = Person.create({ name: "John" });
+
+      expect(JSON.stringify(person)).toEqual('{"name":"John"}');
+    });
+
     test("toJSON should not fail when there is a key in the raw value not represented in the schema", () => {
       const Person = co.map({
         name: z.string(),
@@ -261,11 +299,9 @@ describe("CoMap", async () => {
 
       const person = Person.create({ name: "John", age: 20 });
 
-      person._raw.set("extra", "extra");
+      person.$jazz.raw.set("extra", "extra");
 
       expect(person.toJSON()).toEqual({
-        _type: "CoMap",
-        id: person.id,
         name: "John",
         age: 20,
       });
@@ -287,13 +323,9 @@ describe("CoMap", async () => {
       });
 
       expect(person.toJSON()).toEqual({
-        _type: "CoMap",
-        id: person.id,
         name: "John",
         age: 20,
         friend: {
-          _type: "CoMap",
-          id: person.friend?.id,
           name: "Jane",
           age: 21,
         },
@@ -314,15 +346,13 @@ describe("CoMap", async () => {
         age: 20,
       });
 
-      person.friend = person;
+      person.$jazz.set("friend", person);
 
       expect(person.toJSON()).toEqual({
-        _type: "CoMap",
-        id: person.id,
         name: "John",
         age: 20,
         friend: {
-          _circular: person.id,
+          _circular: person.$jazz.id,
         },
       });
     });
@@ -346,8 +376,6 @@ describe("CoMap", async () => {
         name: "John",
         age: 20,
         birthday: birthday.toISOString(),
-        _type: "CoMap",
-        id: john.id,
       });
     });
 
@@ -379,8 +407,6 @@ describe("CoMap", async () => {
       const john = Person.create({ name: "John", age: 30, x: 1 });
 
       expect(john.toJSON()).toEqual({
-        _type: "CoMap",
-        id: john.id,
         name: "John",
         age: 30,
       });
@@ -399,9 +425,9 @@ describe("CoMap", async () => {
       expect(person.age).toEqual(20);
       expect(person.extra).toBeUndefined();
 
-      person.name = "Jane";
-      person.age = 28;
-      person.extra = "extra";
+      person.$jazz.set("name", "Jane");
+      person.$jazz.set("age", 28);
+      person.$jazz.set("extra", "extra");
 
       expect(person.name).toEqual("Jane");
       expect(person.age).toEqual(28);
@@ -436,7 +462,7 @@ describe("CoMap", async () => {
       );
 
       const userB = await createJazzTestAccount();
-      const loadedPersonA = await Person.load(personA.id, {
+      const loadedPersonA = await Person.load(personA.$jazz.id, {
         resolve: true,
         loadAs: userB,
       });
@@ -464,13 +490,13 @@ describe("CoMap", async () => {
 
       const john = Person.create({ name: "John", age: 20 });
 
-      john.name = "Jane";
+      john.$jazz.set("name", "Jane");
 
       expect(john.name).toEqual("Jane");
       expect(john.age).toEqual(20);
     });
 
-    test("delete an optional value", () => {
+    test("delete an optional value by setting it to undefined", () => {
       const Person = co.map({
         name: z.string(),
         age: z.number().optional(),
@@ -478,19 +504,68 @@ describe("CoMap", async () => {
 
       const john = Person.create({ name: "John", age: 20 });
 
-      delete john.age;
+      john.$jazz.set("age", undefined);
 
       expect(john.name).toEqual("John");
       expect(john.age).toEqual(undefined);
 
       expect(john.toJSON()).toEqual({
-        _type: "CoMap",
-        id: john.id,
         name: "John",
       });
+      // The CoMap proxy hides the age property from the `in` operator
+      expect("age" in john).toEqual(false);
+      // The key still exists, since age === undefined
+      expect(Object.keys(john)).toEqual(["name", "age"]);
     });
 
-    test("update a reference", () => {
+    test("delete optional properties using $jazz.delete", () => {
+      const Dog = co.map({
+        name: z.string(),
+      });
+
+      const Person = co.map({
+        name: z.string(),
+        age: z.number().optional(),
+        pet: Dog.optional(),
+      });
+
+      const john = Person.create({
+        name: "John",
+        age: 20,
+        pet: { name: "Rex" },
+      });
+
+      john.$jazz.delete("age");
+      john.$jazz.delete("pet");
+
+      expect(john.age).not.toBeDefined();
+      expect(john.pet).not.toBeDefined();
+      expect(john.toJSON()).toEqual({
+        name: "John",
+      });
+      expect("age" in john).toEqual(false);
+      expect("pet" in john).toEqual(false);
+      expect(Object.keys(john)).toEqual(["name"]);
+    });
+
+    test("cannot delete required properties using $jazz.delete", () => {
+      const Dog = co.map({
+        name: z.string(),
+      });
+      const Person = co.map({
+        name: z.string(),
+        pet: Dog,
+      });
+
+      const john = Person.create({ name: "John", pet: { name: "Rex" } });
+
+      // @ts-expect-error - should not allow deleting required primitive properties
+      john.$jazz.delete("name");
+      // @ts-expect-error - should not allow deleting required reference properties
+      john.$jazz.delete("pet");
+    });
+
+    test("update a reference using a CoValue", () => {
       const Dog = co.map({
         name: z.string(),
       });
@@ -507,12 +582,128 @@ describe("CoMap", async () => {
         dog: Dog.create({ name: "Rex" }),
       });
 
-      john.dog = Dog.create({ name: "Fido" });
+      john.$jazz.set("dog", Dog.create({ name: "Fido" }));
 
       expect(john.dog?.name).toEqual("Fido");
     });
 
-    test("changes should be listed in _edits", () => {
+    describe("update a reference using a JSON object", () => {
+      const Dog = co.map({
+        type: z.literal("dog"),
+        name: z.string(),
+      });
+      const Cat = co.map({
+        type: z.literal("cat"),
+        name: z.string(),
+      });
+      const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+      const Person = co.map({
+        name: co.plainText(),
+        bio: co.richText().optional(),
+        dog: Dog,
+        get friends() {
+          return co.list(Person);
+        },
+        reactions: co.feed(co.plainText()),
+        pet: Pet,
+        pets: co.record(z.string(), Pet),
+      });
+
+      let person: ReturnType<typeof Person.create>;
+
+      beforeEach(() => {
+        person = Person.create({
+          name: "John",
+          bio: "I am a software engineer",
+          dog: { type: "dog", name: "Rex" },
+          friends: [
+            {
+              name: "Jane",
+              bio: "I am a mechanical engineer",
+              dog: { type: "dog", name: "Fido" },
+              friends: [],
+              reactions: [],
+              pet: { type: "dog", name: "Fido" },
+              pets: {},
+            },
+          ],
+          reactions: ["👎", "👍"],
+          pet: { type: "cat", name: "Whiskers" },
+          pets: {
+            dog: { type: "dog", name: "Rex" },
+            cat: { type: "cat", name: "Whiskers" },
+          },
+        });
+      });
+
+      test("automatically creates CoValues for plain text reference", () => {
+        person.$jazz.set("name", "Jack");
+        expect(person.name.toString()).toEqual("Jack");
+      });
+
+      test("automatically creates CoValues for rich text reference", () => {
+        person.$jazz.set("bio", "I am a lawyer");
+        expect(person.bio!.toString()).toEqual("I am a lawyer");
+      });
+
+      test("automatically creates CoValues for CoMap reference", () => {
+        person.$jazz.set("dog", { type: "dog", name: "Fido" });
+        expect(person.dog.name).toEqual("Fido");
+      });
+
+      test("automatically creates CoValues for CoRecord reference", () => {
+        person.$jazz.set("pets", {
+          dog: { type: "dog", name: "Fido" },
+        });
+        expect(person.pets.dog?.name).toEqual("Fido");
+      });
+
+      test("automatically creates CoValues for CoList reference", () => {
+        person.$jazz.set("friends", [
+          {
+            name: "Jane",
+            bio: "I am a mechanical engineer",
+            dog: { type: "dog", name: "Firulais" },
+            friends: [],
+            reactions: [],
+            pet: { type: "cat", name: "Nala" },
+            pets: {},
+          },
+        ]);
+        expect(person.friends[0]!.name.toString()).toEqual("Jane");
+        expect(person.friends[0]!.dog.name).toEqual("Firulais");
+        expect(person.friends[0]!.pet.name).toEqual("Nala");
+      });
+
+      test("automatically creates CoValues for CoFeed reference", () => {
+        person.$jazz.set("reactions", ["🧑‍🔬"]);
+        expect(person.reactions.byMe?.value?.toString()).toEqual("🧑‍🔬");
+      });
+
+      test("automatically creates CoValues for discriminated union reference", () => {
+        person.$jazz.set("pet", { type: "cat", name: "Salem" });
+        expect(person.pet.name).toEqual("Salem");
+      });
+
+      test("undefined properties can be ommited", () => {
+        person.$jazz.set("friends", [
+          {
+            name: "Jane",
+            // bio is omitted
+            dog: { type: "dog", name: "Firulais" },
+            friends: [],
+            reactions: [],
+            pet: { type: "cat", name: "Nala" },
+            pets: {},
+          },
+        ]);
+
+        expect(person.friends[0]!.name.toString()).toEqual("Jane");
+        expect(person.friends[0]!.bio).toBeUndefined();
+      });
+    });
+
+    test("changes should be listed in getEdits()", () => {
       const Person = co.map({
         name: z.string(),
         age: z.number(),
@@ -522,9 +713,9 @@ describe("CoMap", async () => {
 
       const me = Account.getMe();
 
-      john.age = 21;
+      john.$jazz.set("age", 21);
 
-      expect(john._edits.age?.all).toEqual([
+      expect(john.$jazz.getEdits().age?.all).toEqual([
         expect.objectContaining({
           value: 20,
           key: "age",
@@ -538,17 +729,120 @@ describe("CoMap", async () => {
           madeAt: expect.any(Date),
         }),
       ]);
-      expect(john._edits.age?.all[0]?.by).toMatchObject({
-        _type: "Account",
-        id: me.id,
+      expect(john.$jazz.getEdits().age?.all[0]?.by).toMatchObject({
+        [TypeSym]: "Account",
+        $jazz: expect.objectContaining({
+          id: me.$jazz.id,
+        }),
       });
-      expect(john._edits.age?.all[1]?.by).toMatchObject({
-        _type: "Account",
-        id: me.id,
+      expect(john.$jazz.getEdits().age?.all[1]?.by).toMatchObject({
+        [TypeSym]: "Account",
+        $jazz: expect.objectContaining({
+          id: me.$jazz.id,
+        }),
       });
     });
   });
 
+  describe("has", () => {
+    test("should return true if the key is defined", () => {
+      const Person = co.map({
+        name: z.string(),
+        age: z.number().optional(),
+      });
+
+      const person = Person.create({ name: "John", age: 20 });
+
+      expect(person.$jazz.has("name")).toBe(true);
+      expect(person.$jazz.has("age")).toBe(true);
+    });
+
+    test("should return true if the key was set to undefined", () => {
+      const Person = co.map({
+        name: z.string(),
+        age: z.number().optional(),
+      });
+
+      const person = Person.create({ name: "John" });
+
+      person.$jazz.set("age", undefined);
+
+      expect(person.$jazz.has("age")).toBe(true);
+    });
+
+    test("should return false if the key is not defined", () => {
+      const Person = co.map({
+        name: z.string(),
+        age: z.number().optional(),
+      });
+
+      const person = Person.create({ name: "John" });
+
+      expect(person.$jazz.has("age")).toBe(false);
+    });
+
+    test("should return false if the key was deleted", () => {
+      const Person = co.map({
+        name: z.string(),
+        age: z.number().optional(),
+      });
+
+      const person = Person.create({ name: "John", age: 20 });
+
+      person.$jazz.delete("age");
+
+      expect(person.$jazz.has("age")).toBe(false);
+    });
+
+    test("should not load the referenced CoValue", async () => {
+      const Person = co.map({
+        name: co.plainText(),
+      });
+
+      const { clientAccount, serverAccount } = await setupTwoNodes();
+
+      const person = Person.create(
+        {
+          name: "John",
+        },
+        { owner: Group.create(serverAccount).makePublic() },
+      );
+
+      const loadedPerson = await Person.load(person.$jazz.id, {
+        resolve: true,
+        loadAs: clientAccount,
+      });
+
+      assert(loadedPerson);
+      expect(loadedPerson.$jazz.has("name")).toBe(true);
+      expect(loadedPerson.name).toBeNull();
+    });
+
+    test("should return true even if the viewer doesn't have access to the referenced CoValue", async () => {
+      const Person = co.map({
+        name: co.plainText(),
+      });
+
+      const person = Person.create(
+        // UserB has no access to name
+        { name: co.plainText().create("John", Group.create()) },
+        // UserB has access to person
+        { owner: Group.create().makePublic() },
+      );
+
+      const userB = await createJazzTestAccount();
+
+      const loadedPerson = await Person.load(person.$jazz.id, {
+        resolve: true,
+        loadAs: userB,
+      });
+
+      assert(loadedPerson);
+      expect(loadedPerson.$jazz.has("name")).toBe(true);
+      expect(loadedPerson.name).toBeNull();
+    });
+  });
+
   test("Enum of maps", () => {
     const ChildA = co.map({
       type: z.literal("a"),
@@ -576,7 +870,7 @@ describe("CoMap", async () => {
     expect(mapWithEnum.name).toEqual("enum");
     expect(mapWithEnum.child?.type).toEqual("a");
     expect(mapWithEnum.child?.value).toEqual(5);
-    expect(mapWithEnum.child?.id).toBeDefined();
+    expect(mapWithEnum.child?.$jazz.id).toBeDefined();
 
     // TODO: properly support narrowing once we get rid of the coField marker
     // if (mapWithEnum.child?.type === "a") {
@@ -604,7 +898,7 @@ describe("CoMap resolution", async () => {
       dog: Dog.create({ name: "Rex", breed: "Labrador" }),
     });
 
-    const loadedPerson = await Person.load(person.id, {
+    const loadedPerson = await Person.load(person.$jazz.id, {
       resolve: {
         dog: true,
       },
@@ -632,7 +926,7 @@ describe("CoMap resolution", async () => {
       dog: Dog.create({ name: "Rex", breed: "Labrador" }),
     });
 
-    const loadedPerson = await Person.load(person.id);
+    const loadedPerson = await Person.load(person.$jazz.id);
 
     assert(loadedPerson);
     expect(loadedPerson.dog?.name).toEqual("Rex");
@@ -664,7 +958,7 @@ describe("CoMap resolution", async () => {
 
     const userB = await createJazzTestAccount();
 
-    const loadedPerson = await Person.load(person.id, {
+    const loadedPerson = await Person.load(person.$jazz.id, {
       resolve: {
         dog: true,
       },
@@ -700,7 +994,7 @@ describe("CoMap resolution", async () => {
     );
 
     const userB = await createJazzTestAccount();
-    const loadedPerson = await Person.load(person.id, {
+    const loadedPerson = await Person.load(person.$jazz.id, {
       loadAs: userB,
     });
 
@@ -726,8 +1020,8 @@ describe("CoMap resolution", async () => {
     const currentAccount = Account.getMe();
 
     // Disconnect the current account
-    currentAccount._raw.core.node.syncManager
-      .getServerPeers(currentAccount._raw.id)
+    currentAccount.$jazz.localNode.syncManager
+      .getServerPeers(currentAccount.$jazz.raw.id)
       .forEach((peer) => {
         peer.gracefulShutdown();
       });
@@ -747,7 +1041,7 @@ describe("CoMap resolution", async () => {
     const userB = await createJazzTestAccount();
 
     // We expect that the test doesn't hang here and immediately returns null
-    const loadedPerson = await Person.load(person.id, {
+    const loadedPerson = await Person.load(person.$jazz.id, {
       loadAs: userB,
       skipRetry: true,
     });
@@ -773,8 +1067,8 @@ describe("CoMap resolution", async () => {
     const currentAccount = Account.getMe();
 
     // Disconnect the current account
-    currentAccount._raw.core.node.syncManager
-      .getServerPeers(currentAccount._raw.id)
+    currentAccount.$jazz.localNode.syncManager
+      .getServerPeers(currentAccount.$jazz.raw.id)
       .forEach((peer) => {
         peer.gracefulShutdown();
       });
@@ -793,7 +1087,7 @@ describe("CoMap resolution", async () => {
 
     const userB = await createJazzTestAccount();
     let resolved = false;
-    const promise = Person.load(person.id, {
+    const promise = Person.load(person.$jazz.id, {
       loadAs: userB,
       skipRetry: false,
     });
@@ -806,7 +1100,7 @@ describe("CoMap resolution", async () => {
     expect(resolved).toBe(false);
 
     // Reconnect the current account
-    currentAccount._raw.core.node.syncManager.addPeer(
+    currentAccount.$jazz.localNode.syncManager.addPeer(
       getPeerConnectedToTestSyncServer(),
     );
 
@@ -842,15 +1136,15 @@ describe("CoMap resolution", async () => {
     );
 
     const userB = await createJazzTestAccount();
-    const loadedPerson = await Person.load(person.id, {
+    const loadedPerson = await Person.load(person.$jazz.id, {
       loadAs: userB,
     });
 
     assert(loadedPerson);
 
-    expect(loadedPerson._refs.dog?.id).toBe(person.dog!.id);
+    expect(loadedPerson.$jazz.refs.dog?.id).toBe(person.dog!.$jazz.id);
 
-    const dog = await loadedPerson._refs.dog?.load();
+    const dog = await loadedPerson.$jazz.refs.dog?.load();
 
     assert(dog);
 
@@ -879,7 +1173,7 @@ describe("CoMap resolution", async () => {
     const spy = vi.fn((person) => updates.push(person));
 
     Person.subscribe(
-      person.id,
+      person.$jazz.id,
       {
         resolve: {
           dog: true,
@@ -896,7 +1190,7 @@ describe("CoMap resolution", async () => {
 
     expect(updates[0]?.dog.name).toEqual("Rex");
 
-    person.dog!.name = "Fido";
+    person.dog!.$jazz.set("name", "Fido");
 
     await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
 
@@ -926,7 +1220,7 @@ describe("CoMap resolution", async () => {
     const updates: Loaded<typeof Person>[] = [];
     const spy = vi.fn((person) => updates.push(person));
 
-    Person.subscribe(person.id, {}, spy);
+    Person.subscribe(person.$jazz.id, {}, spy);
 
     expect(spy).not.toHaveBeenCalled();
 
@@ -936,7 +1230,7 @@ describe("CoMap resolution", async () => {
 
     expect(updates[0]?.dog?.name).toEqual("Rex");
 
-    person.dog!.name = "Fido";
+    person.dog!.$jazz.set("name", "Fido");
 
     await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
 
@@ -968,7 +1262,7 @@ describe("CoMap resolution", async () => {
 
     subscribeToCoValue(
       coValueClassFromCoValueClassOrSchema(Person), // TODO: we should get rid of the conversion in the future
-      person.id,
+      person.$jazz.id,
       {
         syncResolution: true,
         loadAs: Account.getMe(),
@@ -983,7 +1277,7 @@ describe("CoMap resolution", async () => {
 
     expect(spy).toHaveBeenCalledTimes(1);
 
-    person.dog!.name = "Fido";
+    person.dog!.$jazz.set("name", "Fido");
 
     expect(spy).toHaveBeenCalledTimes(2);
 
@@ -1022,7 +1316,7 @@ describe("CoMap resolution", async () => {
     const spy = vi.fn((person) => updates.push(person));
 
     Person.subscribe(
-      person.id,
+      person.$jazz.id,
       {
         resolve: {
           dog: true,
@@ -1040,7 +1334,7 @@ describe("CoMap resolution", async () => {
 
     expect(updates[0]?.dog.name).toEqual("Rex");
 
-    person.dog!.name = "Fido";
+    person.dog!.$jazz.set("name", "Fido");
 
     await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
 
@@ -1079,7 +1373,7 @@ describe("CoMap resolution", async () => {
     const userB = await createJazzTestAccount();
 
     Person.subscribe(
-      person.id,
+      person.$jazz.id,
       {
         loadAs: userB,
       },
@@ -1094,7 +1388,7 @@ describe("CoMap resolution", async () => {
 
     expect(updates[0]?.dog?.name).toEqual("Rex");
 
-    person.dog!.name = "Fido";
+    person.dog!.$jazz.set("name", "Fido");
 
     await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
 
@@ -1125,7 +1419,7 @@ describe("CoMap resolution", async () => {
     const spy = vi.fn((person) => updates.push(person));
 
     Person.subscribe(
-      person.id,
+      person.$jazz.id,
       {
         resolve: {
           dog: true,
@@ -1142,7 +1436,7 @@ describe("CoMap resolution", async () => {
 
     expect(updates[0]?.dog.name).toEqual("Rex");
 
-    person.dog!.name = "Fido";
+    person.dog!.$jazz.set("name", "Fido");
 
     await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
 
@@ -1190,7 +1484,7 @@ describe("CoMap applyDiff", async () => {
       isActive: false,
     };
 
-    map.applyDiff(newValues);
+    map.$jazz.applyDiff(newValues);
 
     expect(map.name).toEqual("Bob");
     expect(map.age).toEqual(35);
@@ -1200,13 +1494,17 @@ describe("CoMap applyDiff", async () => {
   });
 
   test("applyDiff with nested changes", () => {
+    const originalNestedMap = NestedMap.create(
+      { value: "original" },
+      { owner: me },
+    );
     const map = TestMap.create(
       {
         name: "Charlie",
         age: 25,
         isActive: true,
         birthday: new Date("1995-01-01"),
-        nested: NestedMap.create({ value: "original" }, { owner: me }),
+        nested: originalNestedMap,
       },
       { owner: me },
     );
@@ -1216,11 +1514,13 @@ describe("CoMap applyDiff", async () => {
       nested: NestedMap.create({ value: "updated" }, { owner: me }),
     };
 
-    map.applyDiff(newValues);
+    map.$jazz.applyDiff(newValues);
 
     expect(map.name).toEqual("David");
     expect(map.age).toEqual(25);
     expect(map.nested?.value).toEqual("updated");
+    // A new nested CoMap is created
+    expect(map.nested.$jazz.id).not.toBe(originalNestedMap.$jazz.id);
   });
 
   test("applyDiff with encoded fields", () => {
@@ -1239,7 +1539,7 @@ describe("CoMap applyDiff", async () => {
       birthday: new Date("1993-06-15"),
     };
 
-    map.applyDiff(newValues);
+    map.$jazz.applyDiff(newValues);
 
     expect(map.birthday).toEqual(new Date("1993-06-15"));
   });
@@ -1260,11 +1560,11 @@ describe("CoMap applyDiff", async () => {
       optionalField: "New optional value",
     };
 
-    map.applyDiff(newValues);
+    map.$jazz.applyDiff(newValues);
 
     expect(map.optionalField).toEqual("New optional value");
 
-    map.applyDiff({ optionalField: undefined });
+    map.$jazz.applyDiff({ optionalField: undefined });
 
     expect(map.optionalField).toBeUndefined();
   });
@@ -1283,7 +1583,7 @@ describe("CoMap applyDiff", async () => {
 
     const originalJSON = map.toJSON();
 
-    map.applyDiff({});
+    map.$jazz.applyDiff({});
 
     expect(map.toJSON()).toEqual(originalJSON);
   });
@@ -1304,8 +1604,7 @@ describe("CoMap applyDiff", async () => {
       name: "Ian",
       invalidField: "This should be ignored",
     };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    map.applyDiff(newValues as any);
+    map.$jazz.applyDiff(newValues);
 
     expect(map.name).toEqual("Ian");
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1329,7 +1628,7 @@ describe("CoMap applyDiff", async () => {
       optionalNested: undefined,
     };
 
-    map.applyDiff(newValues);
+    map.$jazz.applyDiff(newValues);
 
     expect(map.optionalNested).toBeUndefined();
   });
@@ -1350,10 +1649,31 @@ describe("CoMap applyDiff", async () => {
       nested: undefined,
     };
 
-    expect(() => map.applyDiff(newValues)).toThrowError(
+    expect(() => map.$jazz.applyDiff(newValues)).toThrowError(
       "Cannot set required reference nested to undefined",
     );
   });
+
+  test("applyDiff from JSON", () => {
+    const map = TestMap.create({
+      name: "Alice",
+      age: 30,
+      isActive: true,
+      birthday: new Date("1990-01-01"),
+      nested: NestedMap.create({ value: "original" }),
+    });
+    const originalNestedMap = map.nested;
+
+    const newValues = {
+      nested: { value: "updated" },
+    };
+
+    map.$jazz.applyDiff(newValues);
+
+    expect(map.nested?.value).toEqual("updated");
+    // A new nested CoMap is created
+    expect(map.nested.$jazz.id).not.toBe(originalNestedMap.$jazz.id);
+  });
 });
 
 describe("CoMap Typescript validation", async () => {
@@ -1373,9 +1693,9 @@ describe("CoMap Typescript validation", async () => {
     });
 
     expectTypeOf<typeof TestMap.create>().toBeCallableWith(
+      // @ts-expect-error null can't be passed to a non-optional field
       {
         optional: NestedMap.create({ value: "" }, { owner: me }),
-        // @ts-expect-error null can't be passed to a non-optional field
         required: null,
       },
       { owner: me },
@@ -1439,12 +1759,12 @@ describe("CoMap Typescript validation", async () => {
       { owner: clientAccount },
     );
 
-    await map.waitForSync({ timeout: 1000 });
+    await map.$jazz.waitForSync({ timeout: 1000 });
 
     // Killing the client node so the serverNode can't load the map from it
     clientNode.gracefulShutdown();
 
-    const loadedMap = await serverNode.load(map._raw.id);
+    const loadedMap = await serverNode.load(map.$jazz.raw.id);
 
     expect(loadedMap).not.toBe("unavailable");
   });
@@ -1471,7 +1791,10 @@ describe("Creating and finding unique CoMaps", async () => {
       { owner: group, unique: { name: "Alice" } },
     );
 
-    const foundAlice = await Person.loadUnique({ name: "Alice" }, group.id);
+    const foundAlice = await Person.loadUnique(
+      { name: "Alice" },
+      group.$jazz.id,
+    );
     expect(foundAlice).toEqual(alice);
   });
 
@@ -1494,7 +1817,7 @@ describe("Creating and finding unique CoMaps", async () => {
     // Pattern
     let activeEvent = await Event.loadUnique(
       { identifier: sourceData.identifier },
-      workspace.id,
+      workspace.$jazz.id,
     );
     if (!activeEvent) {
       activeEvent = Event.create(
@@ -1506,7 +1829,7 @@ describe("Creating and finding unique CoMaps", async () => {
         workspace,
       );
     } else {
-      activeEvent.applyDiff({
+      activeEvent.$jazz.applyDiff({
         title: sourceData.title,
         identifier: sourceData.identifier,
         external_id: sourceData._id,
@@ -1589,7 +1912,7 @@ describe("Creating and finding unique CoMaps", async () => {
 
     assert(activeEvent);
 
-    expect(activeEvent._owner).toEqual(account);
+    expect(activeEvent.$jazz.owner).toEqual(account);
   });
 
   test("upserting an existing value", async () => {
@@ -1767,12 +2090,14 @@ describe("Creating and finding unique CoMaps", async () => {
       isCurrentActiveAccount: true,
     });
 
-    const shallowProjectList = await co.list(Project).load(fullProjectList.id, {
-      loadAs: account,
-    });
+    const shallowProjectList = await co
+      .list(Project)
+      .load(fullProjectList.$jazz.id, {
+        loadAs: account,
+      });
     assert(shallowProjectList);
 
-    const publicAccessAsNewAccount = await Group.load(publicAccess.id, {
+    const publicAccessAsNewAccount = await Group.load(publicAccess.$jazz.id, {
       loadAs: account,
     });
     assert(publicAccessAsNewAccount);
@@ -1793,7 +2118,7 @@ describe("Creating and finding unique CoMaps", async () => {
 
     assert(updatedOrg);
 
-    expect(updatedOrg.projects.id).toEqual(fullProjectList.id);
+    expect(updatedOrg.projects.$jazz.id).toEqual(fullProjectList.$jazz.id);
     expect(updatedOrg.projects.length).toBe(1);
     expect(updatedOrg.projects.at(0)?.name).toEqual("My project");
   });
@@ -1843,12 +2168,14 @@ describe("Creating and finding unique CoMaps", async () => {
       isCurrentActiveAccount: true,
     });
 
-    const shallowProjectList = await co.list(Project).load(fullProjectList.id, {
-      loadAs: account,
-    });
+    const shallowProjectList = await co
+      .list(Project)
+      .load(fullProjectList.$jazz.id, {
+        loadAs: account,
+      });
     assert(shallowProjectList);
 
-    const publicAccessAsNewAccount = await Group.load(publicAccess.id, {
+    const publicAccessAsNewAccount = await Group.load(publicAccess.$jazz.id, {
       loadAs: account,
     });
     assert(publicAccessAsNewAccount);
@@ -1869,10 +2196,10 @@ describe("Creating and finding unique CoMaps", async () => {
 
     assert(updatedOrg);
 
-    expect(updatedOrg.projects.id).toEqual(fullProjectList.id);
+    expect(updatedOrg.projects.$jazz.id).toEqual(fullProjectList.$jazz.id);
     expect(updatedOrg.projects.length).toBe(1);
     expect(updatedOrg.projects.at(0)?.name).toEqual("My project");
-    expect(updatedOrg.id).toEqual(myOrg.id);
+    expect(updatedOrg.$jazz.id).toEqual(myOrg.$jazz.id);
   });
 
   test("complex discriminated union", () => {
@@ -2031,58 +2358,6 @@ describe("Creating and finding unique CoMaps", async () => {
   });
 });
 
-describe("castAs", () => {
-  test("should cast a co.map type", () => {
-    const Person = co.map({
-      name: z.string(),
-    });
-
-    const PersonWithAge = co.map({
-      name: z.string(),
-      age: z.number().optional(),
-    });
-
-    const person = Person.create({
-      name: "Alice",
-    });
-
-    const personWithAge = person.castAs(PersonWithAge);
-
-    personWithAge.age = 20;
-
-    expect(personWithAge.age).toEqual(20);
-  });
-
-  test("should still be able to autoload in-memory deps", () => {
-    const Dog = co.map({
-      name: z.string(),
-    });
-
-    const Person = co.map({
-      name: z.string(),
-      dog: Dog,
-    });
-
-    const PersonWithAge = co.map({
-      name: z.string(),
-      age: z.number().optional(),
-      dog: Dog,
-    });
-
-    const person = Person.create({
-      name: "Alice",
-      dog: Dog.create({ name: "Rex" }),
-    });
-
-    const personWithAge = person.castAs(PersonWithAge);
-
-    personWithAge.age = 20;
-
-    expect(personWithAge.age).toEqual(20);
-    expect(personWithAge.dog?.name).toEqual("Rex");
-  });
-});
-
 describe("CoMap migration", () => {
   test("should run on load", async () => {
     const PersonV1 = co.map({
@@ -2098,8 +2373,8 @@ describe("CoMap migration", () => {
       })
       .withMigration((person) => {
         if (person.version === 1) {
-          person.age = 20;
-          person.version = 2;
+          person.$jazz.set("age", 20);
+          person.$jazz.set("version", 2);
         }
       });
 
@@ -2111,7 +2386,7 @@ describe("CoMap migration", () => {
     expect(person?.name).toEqual("Bob");
     expect(person?.version).toEqual(1);
 
-    const loadedPerson = await Person.load(person.id);
+    const loadedPerson = await Person.load(person.$jazz.id);
 
     expect(loadedPerson?.name).toEqual("Bob");
     expect(loadedPerson?.age).toEqual(20);
@@ -2126,9 +2401,9 @@ describe("CoMap migration", () => {
       })
       .withMigration((person) => {
         if (person.version === 1) {
-          person.version = 2;
+          person.$jazz.set("version", 2);
 
-          person._owner.castAs(Group).addMember("everyone", "reader");
+          person.$jazz.owner.addMember("everyone", "reader");
         }
       });
 
@@ -2140,14 +2415,14 @@ describe("CoMap migration", () => {
     expect(person?.name).toEqual("Bob");
     expect(person?.version).toEqual(1);
 
-    const loadedPerson = await Person.load(person.id);
+    const loadedPerson = await Person.load(person.$jazz.id);
 
     expect(loadedPerson?.name).toEqual("Bob");
     expect(loadedPerson?.version).toEqual(2);
 
     const anotherAccount = await createJazzTestAccount();
 
-    const loadedPersonFromAnotherAccount = await Person.load(person.id, {
+    const loadedPersonFromAnotherAccount = await Person.load(person.$jazz.id, {
       loadAs: anotherAccount,
     });
 
@@ -2168,7 +2443,7 @@ describe("CoMap migration", () => {
       version: 1,
     });
 
-    await expect(Person.load(person.id)).rejects.toThrow(
+    await expect(Person.load(person.$jazz.id)).rejects.toThrow(
       "Migration function cannot be async",
     );
   });
@@ -2189,8 +2464,8 @@ describe("CoMap migration", () => {
       version: 1,
     });
 
-    await Person.load(person.id);
-    await Person.load(person.id);
+    await Person.load(person.$jazz.id);
+    await Person.load(person.$jazz.id);
     expect(spy).toHaveBeenCalledTimes(1);
   });
 
@@ -2214,8 +2489,8 @@ describe("CoMap migration", () => {
       })
       .withMigration((person) => {
         if (person.version === 1) {
-          person.age = 20;
-          person.version = 2;
+          person.$jazz.set("age", 20);
+          person.$jazz.set("version", 2);
         }
       });
 
@@ -2230,7 +2505,7 @@ describe("CoMap migration", () => {
       friend: charlie,
     });
 
-    const loaded = await Person.load(bob.id, {
+    const loaded = await Person.load(bob.$jazz.id, {
       resolve: {
         friend: true,
       },
@@ -2249,7 +2524,7 @@ describe("createdAt & lastUpdatedAt", () => {
   test("empty map created time", () => {
     const emptyMap = co.map({}).create({});
 
-    expect(emptyMap._lastUpdatedAt).toEqual(emptyMap._createdAt);
+    expect(emptyMap.$jazz.lastUpdatedAt).toEqual(emptyMap.$jazz.createdAt);
   });
 
   test("created time and last updated time", async () => {
@@ -2259,14 +2534,14 @@ describe("createdAt & lastUpdatedAt", () => {
 
     const person = Person.create({ name: "John" });
 
-    const createdAt = person._createdAt;
-    expect(person._lastUpdatedAt).toEqual(createdAt);
+    const createdAt = person.$jazz.createdAt;
+    expect(person.$jazz.lastUpdatedAt).toEqual(createdAt);
 
     await new Promise((r) => setTimeout(r, 10));
-    person.name = "Jane";
+    person.$jazz.set("name", "Jane");
 
-    expect(person._createdAt).toEqual(createdAt);
-    expect(person._lastUpdatedAt).not.toEqual(createdAt);
+    expect(person.$jazz.createdAt).toEqual(createdAt);
+    expect(person.$jazz.lastUpdatedAt).not.toEqual(createdAt);
   });
 });
 
@@ -2343,10 +2618,10 @@ describe("co.map schema", () => {
       expect(draftPerson.age).toBeUndefined();
       expect(draftPerson.pet).toBeUndefined();
 
-      draftPerson.name = "John";
-      draftPerson.age = 20;
+      draftPerson.$jazz.set("name", "John");
+      draftPerson.$jazz.set("age", 20);
       const rex = Dog.create({ name: "Rex", breed: "Labrador" });
-      draftPerson.pet = rex;
+      draftPerson.$jazz.set("pet", rex);
 
       expect(draftPerson.name).toEqual("John");
       expect(draftPerson.age).toEqual(20);
@@ -2364,7 +2639,7 @@ describe("co.map schema", () => {
       const DraftPerson = Person.partial();
 
       const draftPerson = DraftPerson.create({});
-      draftPerson.extraField = "extra";
+      draftPerson.$jazz.set("extraField", "extra");
 
       expect(draftPerson.extraField).toEqual("extra");
     });
@@ -2431,7 +2706,7 @@ describe("Updating a nested reference", () => {
     group.addMember(player1Account, "reader");
 
     // Load the game to verify the assignment worked
-    const loadedGame = await Game.load(game.id, {
+    const loadedGame = await Game.load(game.$jazz.id, {
       resolve: {
         player1: {
           account: true,
@@ -2450,7 +2725,7 @@ describe("Updating a nested reference", () => {
     const playSelection = PlaySelection.create({ value: "rock", group }, group);
 
     // Assign the play selection to player1 (similar to the route logic)
-    loadedGame.player1.playSelection = playSelection;
+    loadedGame.player1.$jazz.set("playSelection", playSelection);
 
     // Verify that the playSelection is not null and has the expected value
     expect(loadedGame.player1.playSelection).not.toBeNull();
@@ -2499,7 +2774,7 @@ describe("Updating a nested reference", () => {
     });
 
     // Load the game to verify the assignment worked
-    const loadedGame = await Game.load(game.id, {
+    const loadedGame = await Game.load(game.$jazz.id, {
       resolve: {
         player1: {
           account: true,
@@ -2518,10 +2793,12 @@ describe("Updating a nested reference", () => {
     const playSelection = PlaySelection.create({ value: "scissors" });
 
     // Assign the play selection to player1 (similar to the route logic)
-    loadedGame.player1.playSelection = playSelection;
+    loadedGame.player1.$jazz.set("playSelection", playSelection);
 
     // Verify that the playSelection is not null and has the expected value
-    expect(loadedGame.player1.playSelection.id).toBe(playSelection.id);
+    expect(loadedGame.player1.playSelection.$jazz.id).toBe(
+      playSelection.$jazz.id,
+    );
     expect(loadedGame.player1.playSelection.value).toEqual("scissors");
   });
 });