jazz-tools 0.17.14 → 0.18.0

package/src/tools/tests/coMap.record.test-d.ts

@@ -24,12 +24,12 @@ describe("CoMap.Record", () => {
       matches(person);
     });
 
-    test("has the _owner property", () => {
+    test("has the owner property", () => {
       const Person = co.record(z.string(), z.string());
 
       const person = Person.create({ name: "John" }, Account.getMe());
 
-      expectTypeOf(person._owner).toEqualTypeOf<Account | Group>();
+      expectTypeOf(person.$jazz.owner).toEqualTypeOf<Group>();
     });
 
     test("Record with reference", () => {
@@ -128,7 +128,7 @@ describe("CoMap.Record", () => {
         pet1: Dog.create({ name: "Rex" }),
       });
 
-      person.pet1!.owner = person;
+      person.pet1!.$jazz.set("owner", person);
 
       type ExpectedType = {
         [key: string]: Loaded<typeof Dog> | undefined;
@@ -156,7 +156,7 @@ describe("CoMap.Record", () => {
         pet2: Dog.create({ name: "Fido", breed: "Poodle" }),
       });
 
-      const loadedPerson = await Person.load(person.id, {
+      const loadedPerson = await Person.load(person.$jazz.id, {
         resolve: {
           $each: true,
         },
@@ -186,7 +186,7 @@ describe("CoMap.Record", () => {
         pet2: Dog.create({ name: "Fido", breed: "Poodle" }),
       });
 
-      const loadedPerson = await Person.load(person.id, {
+      const loadedPerson = await Person.load(person.$jazz.id, {
         resolve: {
           pet1: true,
         },
@@ -222,7 +222,7 @@ describe("CoMap.Record", () => {
       const userId: string = "pet1";
       const userId2: string = "pet3";
 
-      const loadedPerson = await Person.load(person.id, {
+      const loadedPerson = await Person.load(person.$jazz.id, {
         resolve: {
           [userId]: true,
           pet2: true,
@@ -262,7 +262,7 @@ describe("CoMap.Record", () => {
         pet2: Dog.create({ name: "Fido", breed: "Poodle" }),
       });
 
-      const loadedPerson = await Person.load(person.id);
+      const loadedPerson = await Person.load(person.$jazz.id);
 
       type Expect = NonNullable<typeof loadedPerson> extends never
         ? "error: is never"
@@ -291,18 +291,14 @@ describe("CoMap.Record", () => {
         pet2: Dog.create({ name: "Fido", breed: "Poodle" }),
       });
 
-      const loadedPerson = await Person.load(person.id, {
+      const loadedPerson = await Person.load(person.$jazz.id, {
         resolve: {
           $each: { $onError: null },
         },
       });
 
       type ExpectedType = {
-        [key: string]:
-          | (Loaded<typeof Dog> & {
-              $onError: never;
-            })
-          | null;
+        [key: string]: Loaded<typeof Dog> | null;
       } | null;
 
       function matches(value: ExpectedType) {

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

@@ -13,6 +13,7 @@ import { Loaded } from "../implementation/zodSchema/zodSchema.js";
 import { Account } from "../index.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { waitFor } from "./utils.js";
+import { TypeSym } from "../internal.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -54,7 +55,7 @@ describe("CoMap.Record", async () => {
     test("create a Record with nullable values", () => {
       const Person = co.record(z.string(), z.string().nullable());
       const person = Person.create({ name: "John", age: null });
-      person.bio = null;
+      person.$jazz.set("bio", null);
       expect(person.name).toEqual("John");
       expect(person.age).toEqual(null);
       expect(person.bio).toEqual(null);
@@ -75,7 +76,7 @@ describe("CoMap.Record", async () => {
       const person = Person.create({ name: "John" }, Account.getMe());
 
       expect(person.name).toEqual("John");
-      expect(person._raw.get("name")).toEqual("John");
+      expect(person.$jazz.raw.get("name")).toEqual("John");
     });
 
     test("create a Record with a group as owner", () => {
@@ -84,7 +85,7 @@ describe("CoMap.Record", async () => {
       const person = Person.create({ name: "John" }, Group.create());
 
       expect(person.name).toEqual("John");
-      expect(person._raw.get("name")).toEqual("John");
+      expect(person.$jazz.raw.get("name")).toEqual("John");
     });
 
     test("Empty schema", () => {
@@ -120,7 +121,7 @@ describe("CoMap.Record", async () => {
 
       const person = Person.create({ name: "John" });
 
-      person.name = "Jane";
+      person.$jazz.set("name", "Jane");
 
       expect(person.name).toEqual("Jane");
     });
@@ -130,14 +131,15 @@ describe("CoMap.Record", async () => {
 
       const person = Person.create({ name: "John", age: "20" });
 
-      delete person.age;
+      // Deleting a non-existent property does nothing
+      person.$jazz.delete("nonExistentProperty");
+
+      person.$jazz.delete("age");
 
       expect(person.name).toEqual("John");
       expect("age" in person).toEqual(false);
 
       expect(person.toJSON()).toEqual({
-        _type: "CoMap",
-        id: person.id,
         name: "John",
       });
     });
@@ -153,21 +155,21 @@ describe("CoMap.Record", async () => {
         pet1: Dog.create({ name: "Rex" }),
       });
 
-      person.pet1 = Dog.create({ name: "Fido" });
+      person.$jazz.set("pet1", Dog.create({ name: "Fido" }));
 
       expect(person.pet1?.name).toEqual("Fido");
     });
 
-    test("changes should be listed in _edits", () => {
+    test("changes should be listed in getEdits()", () => {
       const Person = co.record(z.string(), z.string());
 
       const person = Person.create({ name: "John" });
 
       const me = Account.getMe();
 
-      person.name = "Jane";
+      person.$jazz.set("name", "Jane");
 
-      const edits = person._edits.name?.all;
+      const edits = person.$jazz.getEdits().name?.all;
       expect(edits).toEqual([
         expect.objectContaining({
           value: "John",
@@ -182,8 +184,14 @@ describe("CoMap.Record", async () => {
           madeAt: expect.any(Date),
         }),
       ]);
-      expect(edits?.[0]?.by).toMatchObject({ _type: "Account", id: me.id });
-      expect(edits?.[1]?.by).toMatchObject({ _type: "Account", id: me.id });
+      expect(edits?.[0]?.by).toMatchObject({
+        [TypeSym]: "Account",
+        $jazz: expect.objectContaining({ id: me.$jazz.id }),
+      });
+      expect(edits?.[1]?.by).toMatchObject({
+        [TypeSym]: "Account",
+        $jazz: expect.objectContaining({ id: me.$jazz.id }),
+      });
     });
   });
 
@@ -201,7 +209,7 @@ describe("CoMap.Record", async () => {
         pet2: Dog.create({ name: "Fido", breed: "Poodle" }),
       });
 
-      const loadedPerson = await Person.load(person.id, {
+      const loadedPerson = await Person.load(person.$jazz.id, {
         resolve: {
           $each: true,
         },
@@ -225,7 +233,7 @@ describe("CoMap.Record", async () => {
         pet2: Dog.create({ name: "Fido", breed: "Poodle" }),
       });
 
-      const loadedPerson = await Person.load(person.id, {
+      const loadedPerson = await Person.load(person.$jazz.id, {
         resolve: {
           pet1: true,
         },
@@ -248,7 +256,7 @@ describe("CoMap.Record", async () => {
         pet2: Dog.create({ name: "Fido", breed: "Poodle" }),
       });
 
-      const loadedPerson = await Person.load(person.id, {
+      const loadedPerson = await Person.load(person.$jazz.id, {
         resolve: {
           pet3: true,
         },
@@ -270,7 +278,7 @@ describe("CoMap.Record", async () => {
         pet2: Dog.create({ name: "Fido", breed: "Poodle" }),
       });
 
-      const loadedPerson = await Person.load(person.id);
+      const loadedPerson = await Person.load(person.$jazz.id);
 
       assert(loadedPerson);
       expect(loadedPerson.pet1?.name).toEqual("Rex");
@@ -293,7 +301,7 @@ describe("CoMap.Record", async () => {
       const spy = vi.fn((person) => updates.push(person));
 
       Person.subscribe(
-        person.id,
+        person.$jazz.id,
         {
           resolve: {
             $each: true,
@@ -310,7 +318,7 @@ describe("CoMap.Record", async () => {
 
       expect(updates[0]?.pet1?.name).toEqual("Rex");
 
-      person.pet1 = Dog.create({ name: "Fido", breed: "Poodle" });
+      person.$jazz.set("pet1", Dog.create({ name: "Fido", breed: "Poodle" }));
 
       await waitFor(() => expect(spy).toHaveBeenCalledTimes(2));
 
@@ -471,7 +479,10 @@ describe("CoRecord unique methods", () => {
       { owner: group, unique: "test-record" },
     );
 
-    const foundRecord = await ItemRecord.loadUnique("test-record", group.id);
+    const foundRecord = await ItemRecord.loadUnique(
+      "test-record",
+      group.$jazz.id,
+    );
     expect(foundRecord).toEqual(originalRecord);
     expect(foundRecord?.item1).toBe(1);
     expect(foundRecord?.item2).toBe(2);
@@ -481,7 +492,10 @@ describe("CoRecord unique methods", () => {
     const ItemRecord = co.record(z.string(), z.number());
     const group = Group.create();
 
-    const foundRecord = await ItemRecord.loadUnique("non-existent", group.id);
+    const foundRecord = await ItemRecord.loadUnique(
+      "non-existent",
+      group.$jazz.id,
+    );
     expect(foundRecord).toBeNull();
   });
 
@@ -560,7 +574,7 @@ describe("CoRecord unique methods", () => {
       { owner: group, unique: "find-test" },
     );
 
-    const foundId = ItemRecord.findUnique("find-test", group.id);
-    expect(foundId).toBe(originalRecord.id);
+    const foundId = ItemRecord.findUnique("find-test", group.$jazz.id);
+    expect(foundId).toBe(originalRecord.$jazz.id);
   });
 });

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

@@ -45,14 +45,14 @@ describe("CoMap", async () => {
       matches(john);
     });
 
-    test("has the _owner property", () => {
+    test("has the owner property", () => {
       const Person = co.map({
         name: z.string(),
       });
 
       const john = Person.create({ name: "John" }, Account.getMe());
 
-      expectTypeOf(john._owner).toEqualTypeOf<Account | Group>();
+      expectTypeOf(john.$jazz.owner).toEqualTypeOf<Group>();
     });
 
     test("create CoMap with reference using CoValue", () => {
@@ -99,10 +99,10 @@ describe("CoMap", async () => {
         },
       });
 
+      // @ts-expect-error - Object literal may only specify known properties
       const person = Person.create({
         // @ts-expect-error - breed is missing
         dog1: { name: "Rex", items },
-        // @ts-expect-error - Object literal may only specify known properties
         dog2: { name: "Fido", breed: "Labrador", extra: "extra" },
         friend: {
           dog1: {
@@ -278,7 +278,29 @@ describe("CoMap", async () => {
         dog: Dog.create({ name: "Rex" }),
       });
 
-      john.dog = Dog.create({ name: "Fido" });
+      john.$jazz.set("dog", Dog.create({ name: "Fido" }));
+    });
+
+    test("cannot update a non-existing key", () => {
+      const Person = co.map({
+        name: z.string(),
+      });
+
+      const john = Person.create({ name: "John" });
+
+      // @ts-expect-error - Argument of type '"non-existing-key"' is not assignable to parameter of type '"name"'
+      john.$jazz.set("non-existing-key", "Jane");
+    });
+
+    test("cannot set a value with an incorrect type", () => {
+      const Person = co.map({
+        name: z.string(),
+      });
+
+      const john = Person.create({ name: "John" });
+
+      // @ts-expect-error - Argument of type 'number' is not assignable to parameter of type 'string'
+      john.$jazz.set("name", 12);
     });
 
     test("update a reference on a loaded value", () => {
@@ -301,10 +323,13 @@ describe("CoMap", async () => {
         dog: Dog.create({ name: "Rex", siblings: co.list(Dog).create([]) }),
       }) as Loaded<typeof Person, { dog: { siblings: true } }>;
 
-      john.dog = Dog.create({
-        name: "Fido",
-        siblings: co.list(Dog).create([]),
-      });
+      john.$jazz.set(
+        "dog",
+        Dog.create({
+          name: "Fido",
+          siblings: co.list(Dog).create([]),
+        }),
+      );
     });
   });
 
@@ -516,7 +541,7 @@ describe("CoMap resolution", async () => {
       dog2: Dog.create({ name: "Fido", breed: "Poodle" }),
     });
 
-    const loadedPerson = await Person.load(person.id, {
+    const loadedPerson = await Person.load(person.$jazz.id, {
       resolve: {
         dog1: true,
       },
@@ -564,7 +589,7 @@ describe("CoMap resolution", async () => {
 
     const userId: string = "dog1";
 
-    const loadedPerson = await Person.load(person.id, {
+    const loadedPerson = await Person.load(person.$jazz.id, {
       resolve: {
         [userId]: true,
       },
@@ -612,7 +637,7 @@ describe("CoMap resolution", async () => {
       dog2: Dog.create({ name: "Fido", breed: "Poodle" }),
     });
 
-    const loadedPerson = await Person.load(person.id, {
+    const loadedPerson = await Person.load(person.$jazz.id, {
       resolve: {
         dog1: true,
         dog2: { $onError: null },
@@ -634,12 +659,9 @@ describe("CoMap resolution", async () => {
 
     assert(loadedPerson);
     expectTypeOf<typeof loadedPerson.dog1.name>().toEqualTypeOf<string>();
-    expectTypeOf<typeof loadedPerson.dog2>().toEqualTypeOf<
-      | (Loaded<typeof Dog> & {
-          $onError: never; // TODO: Clean the $onError from the type
-        })
-      | null
-    >();
+    expectTypeOf<typeof loadedPerson.dog2>().branded.toEqualTypeOf<Loaded<
+      typeof Dog
+    > | null>();
   });
 
   test("loading a map with a nullable field", async () => {
@@ -659,13 +681,13 @@ 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);
 
     expectTypeOf(loadedPerson!).toEqualTypeOf<
       {
-        name: string;
-        age: number | null;
-        dog: Loaded<typeof Dog> | null;
+        readonly name: string;
+        readonly age: number | null;
+        readonly dog: Loaded<typeof Dog> | null;
       } & CoMap
     >();
   });