jazz-tools 0.19.0 → 0.19.2

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

@@ -1,13 +1,16 @@
 import { beforeEach, describe, expect, test, vi } from "vitest";
-import { CoPlainText, Loaded, co, z } from "../exports.js";
+import { CoPlainText, Group, Loaded, co, loadCoValue, z } from "../exports.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { assertLoaded, waitFor } from "./utils.js";
+import type { Account } from "jazz-tools";
 
 describe("co.discriminatedUnion", () => {
+  let account: Account;
+
   beforeEach(async () => {
     await setupJazzTestSync();
 
-    await createJazzTestAccount({
+    account = await createJazzTestAccount({
       isCurrentActiveAccount: true,
       creationProps: { name: "Hermes Puggington" },
     });
@@ -266,7 +269,7 @@ describe("co.discriminatedUnion", () => {
     expect(referenceItem.children[0]?.type).toEqual("note");
   });
 
-  test("load CoValue instances using the DiscriminatedUnion schema", async () => {
+  test("load CoValue instances using the DiscriminatedUnion schema without resolve", async () => {
     const Dog = co.map({
       type: z.literal("dog"),
     });
@@ -281,7 +284,40 @@ describe("co.discriminatedUnion", () => {
     expect(loadedPet.type).toEqual("dog");
   });
 
-  test("subscribe to CoValue instances using the DiscriminatedUnion schema", async () => {
+  test("load CoValue instances using the DiscriminatedUnion schema with deep resolve", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const Dog = co.map({
+      type: z.literal("dog"),
+      owner: Person,
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+      owner: Person,
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const dog = Dog.create({
+      type: "dog",
+      owner: Person.create({
+        name: "John Doe",
+      }),
+    });
+
+    const loadedPet = await Pet.load(dog.$jazz.id, {
+      resolve: {
+        owner: true,
+      },
+    });
+
+    assertLoaded(loadedPet);
+
+    expect(loadedPet?.type).toEqual("dog");
+    expect(loadedPet?.owner.name).toEqual("John Doe");
+  });
+
+  test("subscribe to CoValue instances using the DiscriminatedUnion schema without resolve", async () => {
     const Person = co.map({
       name: z.string(),
     });
@@ -319,7 +355,41 @@ describe("co.discriminatedUnion", () => {
     expect(updates[0]?.name).toEqual("Rex");
   });
 
-  test("should work when one of the options has a dicriminated union field", async () => {
+  test("subscribe to CoValue instances using the DiscriminatedUnion schema with deep resolve", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const Dog = co.map({
+      type: z.literal("dog"),
+      owner: Person,
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+      owner: Person,
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const dog = Dog.create({
+      type: "dog",
+      owner: Person.create({
+        name: "John Doe",
+      }),
+    });
+
+    const spy = vi.fn();
+    Pet.subscribe(dog.$jazz.id, { resolve: { owner: true } }, (pet) => {
+      expect(pet.owner.name).toEqual("John Doe");
+      spy(pet);
+    });
+
+    expect(spy).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(spy).toHaveBeenCalled());
+
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  test("should work when one of the options has a discriminated union field", async () => {
     const Collie = co.map({
       type: z.literal("collie"),
     });
@@ -371,4 +441,276 @@ describe("co.discriminatedUnion", () => {
     assertLoaded(loadedAnimal);
     expect(loadedAnimal.type).toEqual("collie");
   });
+
+  test("load co.discriminatedUnion with deep resolve using loadCoValue", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const Dog = co.map({
+      type: z.literal("dog"),
+      owner: Person,
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+    });
+
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const dog = Dog.create({
+      type: "dog",
+      owner: Person.create({ name: "John Doe" }),
+    });
+
+    const loadedPet = await loadCoValue(Pet.getCoValueClass(), dog.$jazz.id, {
+      resolve: { owner: true },
+      loadAs: account,
+    });
+
+    assertLoaded(loadedPet);
+
+    if (loadedPet.type === "dog") {
+      expect(loadedPet.owner.name).toEqual("John Doe");
+    }
+  });
+
+  test("load co.discriminatedUnion with non-matching deep resolve", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const Dog = co.map({
+      type: z.literal("dog"),
+      owner: Person,
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const cat = Cat.create({
+      type: "cat",
+    });
+
+    const loadedPet = await Pet.load(cat.$jazz.id, {
+      resolve: { owner: true },
+    });
+
+    assertLoaded(loadedPet);
+
+    expect(loadedPet.type).toEqual("cat");
+    // @ts-expect-error - no owner on Cat
+    expect(loadedPet.owner).toBeUndefined();
+  });
+
+  test("load co.discriminatedUnion list with different schemas on deep resolved fields", async () => {
+    // Schema without nested CoValues
+    const Bird = co.map({
+      type: z.literal("bird"),
+      species: z.string(),
+    });
+    const Person = co.map({
+      name: z.string(),
+      bird: Bird,
+    });
+    // Schema with a nested CoValue
+    const Dog = co.map({
+      type: z.literal("dog"),
+      friend: Person,
+    });
+    // Same attribute (friend) with a completely different schema (list)
+    const Cat = co.map({
+      type: z.literal("cat"),
+      get friend() {
+        return co.list(Cat);
+      },
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat, Bird]);
+    const Pets = co.list(Pet);
+
+    const bird = Bird.create({
+      type: "bird",
+      species: "Parrot",
+    });
+
+    const dog = Dog.create({
+      type: "dog",
+      friend: Person.create({ name: "John Doe", bird }),
+    });
+
+    const cat = Cat.create({
+      type: "cat",
+      friend: [{ type: "cat", friend: [{ type: "cat", friend: [] }] }],
+    });
+
+    const pets = Pets.create([dog, cat, bird]);
+
+    const loadedPets = await Pets.load(pets.$jazz.id, {
+      resolve: { $each: { friend: { $each: { friend: true }, bird: true } } },
+    });
+
+    assertLoaded(loadedPets);
+
+    for (const pet of loadedPets) {
+      if (pet.type === "dog") {
+        expect(pet.friend.name).toEqual("John Doe");
+        expect(pet.friend.bird.species).toEqual("Parrot");
+        // @ts-expect-error - no species on Person
+        expect(pet.friend.species).toBeUndefined();
+      } else if (pet.type === "cat") {
+        expect(pet.friend[0]?.type).toEqual("cat");
+        // @ts-expect-error - no name on Bird
+        expect(pet.friend.name).toBeUndefined();
+      }
+    }
+  });
+
+  test("ensureLoaded on co.discriminatedUnion members", async () => {
+    const Person = co.map({
+      name: z.string(),
+    });
+    const Dog = co.map({
+      type: z.literal("dog"),
+      owner: Person,
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+      friend: Person,
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+
+    const dog = Dog.create({
+      type: "dog",
+      owner: Person.create({ name: "John Doe" }),
+    });
+
+    const cat = Cat.create({
+      type: "cat",
+      friend: Person.create({ name: "Jane Doe" }),
+    });
+
+    const pet = await Pet.load(dog.$jazz.id);
+
+    assertLoaded(pet);
+
+    // @ts-expect-error - can't use ensureLoaded before narrowing
+    pet.$jazz.ensureLoaded({
+      resolve: { owner: true },
+    });
+
+    if (pet.type === "dog") {
+      const loadedPet = await pet.$jazz.ensureLoaded({
+        resolve: { owner: true },
+      });
+
+      expect(loadedPet.owner.name).toEqual("John Doe");
+    }
+  });
+
+  describe("Deep loading mutually exclusive nested CoMaps", async () => {
+    const Breed = co.map({
+      type: z.enum(["collie", "border-collie"]),
+    });
+    const Dog = co.map({
+      type: z.literal("dog"),
+      breed: Breed,
+    });
+
+    const Ocean = co.map({
+      name: z.enum(["atlantic", "pacific"]),
+    });
+    const Shark = co.map({
+      type: z.literal("shark"),
+      ocean: Ocean,
+    });
+
+    const Animal = co.discriminatedUnion("type", [Dog, Shark]);
+    const Species = co.list(Animal);
+
+    let species: Loaded<typeof Species>;
+
+    beforeEach(async () => {
+      const group = Group.create();
+      group.makePublic();
+
+      species = Species.create(
+        [
+          {
+            type: "dog",
+            breed: {
+              type: "collie",
+            },
+          },
+          {
+            type: "shark",
+            ocean: {
+              name: "atlantic",
+            },
+          },
+        ],
+        group,
+      );
+    });
+
+    test("co.discriminatedUnion should load with deeply resolved mutually exclusive nested CoMaps", async () => {
+      const loadedSpecies = await Species.load(species.$jazz.id, {
+        resolve: {
+          $each: {
+            breed: true,
+            ocean: true,
+          },
+        },
+      });
+
+      assertLoaded(loadedSpecies);
+
+      // @ts-expect-error - type needs to be narrowed
+      expect(loadedSpecies[0]?.breed.type).toEqual("collie");
+      // @ts-expect-error - type needs to be narrowed
+      expect(loadedSpecies[1]?.ocean.name).toEqual("atlantic");
+
+      for (const animal of loadedSpecies) {
+        if (animal.type === "dog") {
+          expect(animal.breed.type).toBeDefined();
+          // @ts-expect-error - no ocean property on Dog
+          expect(animal.ocean).toBeUndefined();
+        } else if (animal.type === "shark") {
+          expect(animal.ocean.name).toBeDefined();
+          // @ts-expect-error - no breed property on Shark
+          expect(animal.breed).toBeUndefined();
+        }
+      }
+    });
+
+    test("co.discriminatedUnion should load with deeply resolved nested CoMaps with another account as owner", async () => {
+      const alice = await createJazzTestAccount({
+        creationProps: { name: "Alice" },
+        isCurrentActiveAccount: false,
+      });
+
+      const loadedSpecies = await Species.load(species.$jazz.id, {
+        loadAs: alice,
+        resolve: {
+          $each: {
+            breed: true,
+            ocean: true,
+          },
+        },
+      });
+
+      console.log(loadedSpecies.$isLoaded);
+
+      assertLoaded(loadedSpecies);
+
+      for (const animal of loadedSpecies) {
+        if (animal.type === "dog") {
+          expect(animal.breed.type).toBeDefined();
+          // @ts-expect-error - no ocean on Dog
+          expect(animal.ocean).toBeUndefined();
+        } else if (animal.type === "shark") {
+          expect(animal.ocean.name).toBeDefined();
+          // @ts-expect-error - no breed on Shark
+          expect(animal.breed).toBeUndefined();
+        }
+      }
+    });
+  });
 });

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

@@ -112,6 +112,49 @@ describe("Creating a CoVector", async () => {
 
     expect(embedding.$jazz.owner).toEqual(group);
   });
+
+  describe("nested inside a container CoValue", async () => {
+    test("from an array of numbers", () => {
+      const VectorMap = co.map({
+        embedding: EmbeddingSchema,
+      });
+
+      const container = VectorMap.create({
+        embedding: [1, 2, 3],
+      });
+
+      expect(container.embedding).toBeInstanceOf(CoVector);
+      expect(Array.from(container.embedding)).toEqual([1, 2, 3]);
+      const vectorOwner = container.embedding.$jazz.owner;
+      expect(
+        vectorOwner.getParentGroups().map((group) => group.$jazz.id),
+      ).toContain(container.$jazz.owner.$jazz.id);
+
+      container.$jazz.set("embedding", [4, 5, 6]);
+      expect(Array.from(container.embedding)).toEqual([4, 5, 6]);
+    });
+
+    test("from a Float32Array", () => {
+      const VectorList = co.list(EmbeddingSchema);
+
+      const list = VectorList.create([new Float32Array([1, 2, 3])]);
+
+      const vector = list[0];
+      assert(vector);
+      expect(vector).toBeInstanceOf(CoVector);
+      expect(Array.from(vector)).toEqual([1, 2, 3]);
+      const vectorOwner = vector.$jazz.owner;
+      expect(
+        vectorOwner.getParentGroups().map((group) => group.$jazz.id),
+      ).toContain(list.$jazz.owner.$jazz.id);
+
+      list.$jazz.push(new Float32Array([4, 5, 6]));
+
+      const vector2 = list[1];
+      assert(vector2);
+      expect(Array.from(vector2)).toEqual([4, 5, 6]);
+    });
+  });
 });
 
 describe("CoVector structure", async () => {

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

@@ -361,55 +361,49 @@ test("Deep loading a record-like coMap", async () => {
   expect(recordLoaded.key2?.list).toBeTruthy();
 });
 
-test("The resolve type doesn't accept extra keys", async () => {
-  expect.assertions(1);
-
+test("The resolve type doesn't accept extra keys, but the load resolves anyway", async () => {
   const me = await CustomAccount.create({
     creationProps: { name: "Hermes Puggington" },
     crypto: Crypto,
   });
 
-  try {
-    const meLoaded = await me.$jazz.ensureLoaded({
-      resolve: {
-        // @ts-expect-error
-        profile: { stream: true, extraKey: true },
-        // @ts-expect-error
-        root: { list: true, extraKey: true },
-      },
-    });
+  const meLoaded = await me.$jazz.ensureLoaded({
+    resolve: {
+      // @ts-expect-error
+      profile: { stream: true, extraKey: true },
+      // @ts-expect-error
+      root: { list: true, extraKey: true },
+    },
+  });
 
-    await me.$jazz.ensureLoaded({
-      resolve: {
-        // @ts-expect-error
-        root: { list: { $each: true, extraKey: true } },
-      },
-    });
+  await me.$jazz.ensureLoaded({
+    resolve: {
+      // @ts-expect-error
+      root: { list: { $each: true, extraKey: true } },
+    },
+  });
 
-    await me.$jazz.ensureLoaded({
-      resolve: {
-        root: { list: true },
-        // @ts-expect-error
-        extraKey: true,
-      },
-    });
+  await me.$jazz.ensureLoaded({
+    resolve: {
+      root: { list: true },
+      // @ts-expect-error
+      extraKey: true,
+    },
+  });
 
-    // using assignment to check type compatibility
-    const _T:
-      | (Loaded<typeof CustomAccount> & {
-          profile: Loaded<typeof CustomProfile> & {
-            stream: Loaded<typeof TestFeed>;
-            extraKey: never;
-          };
-          root: Loaded<typeof TestMap> & {
-            list: Loaded<typeof TestList>;
-            extraKey: never;
-          };
-        })
-      | null = meLoaded;
-  } catch (e) {
-    expect(e).toBeInstanceOf(Error);
-  }
+  // using assignment to check type compatibility
+  const _T:
+    | (Loaded<typeof CustomAccount> & {
+        profile: Loaded<typeof CustomProfile> & {
+          stream: Loaded<typeof TestFeed>;
+          extraKey: never;
+        };
+        root: Loaded<typeof TestMap> & {
+          list: Loaded<typeof TestList>;
+          extraKey: never;
+        };
+      })
+    | null = meLoaded;
 });
 
 test("The resolve type accepts keys from optional fields", async () => {
@@ -435,7 +429,7 @@ test("The resolve type accepts keys from optional fields", async () => {
   expect(pets[0]?.owner?.name).toEqual("Rex");
 });
 
-test("The resolve type doesn't accept keys from discriminated unions", async () => {
+test("The resolve type accepts keys from discriminated unions", async () => {
   const Person = co.map({
     name: z.string(),
   });
@@ -449,24 +443,25 @@ test("The resolve type doesn't accept keys from discriminated unions", async ()
   const Pet = co.discriminatedUnion("type", [Dog, Cat]);
   const Pets = co.list(Pet);
 
-  const pets = await Pets.create([
+  const pets = Pets.create([
     Dog.create({ type: "dog", owner: Person.create({ name: "Rex" }) }),
+    Cat.create({ type: "cat" }),
   ]);
 
   await pets.$jazz.ensureLoaded({
-    resolve: {
-      $each: true,
-    },
-  });
-
-  await pets.$jazz.ensureLoaded({
-    // @ts-expect-error cannot resolve owner
     resolve: { $each: { owner: true } },
   });
 
   expect(pets).toBeTruthy();
-  if (pets?.[0]?.type === "dog") {
-    expect(pets[0].owner?.name).toEqual("Rex");
+
+  for (const pet of pets) {
+    if (pet.type === "dog") {
+      expect(pet.owner?.name).toEqual("Rex");
+    } else {
+      expect("owner" in pet).toEqual(false);
+      // @ts-expect-error - this should still not appear in the types
+      expect(pet.owner).toBeUndefined();
+    }
   }
 });
 
@@ -1110,7 +1105,7 @@ test("throw when calling ensureLoaded on a ref that's required but missing", asy
   ).rejects.toThrow("Failed to deeply load CoValue " + root.$jazz.id);
 });
 
-test("throw when calling ensureLoaded on a ref that is not defined in the schema", async () => {
+test("returns the value when calling ensureLoaded on a ref that is not defined in the schema", async () => {
   const JazzRoot = co.map({});
 
   const me = await Account.create({
@@ -1120,12 +1115,13 @@ test("throw when calling ensureLoaded on a ref that is not defined in the schema
 
   const root = JazzRoot.create({}, { owner: me });
 
-  await expect(
-    root.$jazz.ensureLoaded({
-      // @ts-expect-error missing required ref
-      resolve: { profile: true },
-    }),
-  ).rejects.toThrow("Failed to deeply load CoValue " + root.$jazz.id);
+  const loadedRoot = await JazzRoot.load(root.$jazz.id, {
+    // @ts-expect-error missing required ref
+    resolve: { profile: true },
+    loadAs: me,
+  });
+
+  expect(loadedRoot.$jazz.loadingState).toBe(CoValueLoadingState.LOADED);
 });
 
 test("should not throw when calling ensureLoaded a record with a deleted ref", async () => {

package/src/tools/tests/schema.resolved.test.ts

@@ -1,4 +1,11 @@
-import { beforeAll, describe, expect, expectTypeOf, test } from "vitest";
+import {
+  assert,
+  beforeAll,
+  describe,
+  expect,
+  expectTypeOf,
+  test,
+} from "vitest";
 import {
   Account,
   co,
@@ -104,6 +111,27 @@ describe("Schema.resolved()", () => {
         profile: true,
       });
     });
+
+    test("to a DiscriminatedUnion schema", () => {
+      const Pet = co.discriminatedUnion("type", [
+        co.map({
+          type: z.literal("dog"),
+          name: co.plainText(),
+        }),
+        co.map({
+          type: z.literal("cat"),
+          name: co.plainText(),
+        }),
+      ]);
+
+      const PetWithName = Pet.resolved({
+        name: true,
+      });
+
+      expect(PetWithName.resolveQuery).toEqual({
+        name: true,
+      });
+    });
   });
 
   describe("the schema's resolve query is used when loading CoValues", () => {
@@ -234,6 +262,47 @@ describe("Schema.resolved()", () => {
         expect(loadedAccount.profile.$isLoaded).toBe(true);
         expect(loadedAccount.profile.name).toBe("Hermes Puggington");
       });
+
+      test("for DiscriminatedUnion", async () => {
+        const Person = co.map({
+          name: co.plainText(),
+        });
+        const Dog = co.map({
+          type: z.literal("dog"),
+          name: co.plainText(),
+          owner: Person,
+        });
+        const Cat = co.map({
+          type: z.literal("cat"),
+          name: co.plainText(),
+        });
+        const Pet = co.discriminatedUnion("type", [Dog, Cat]).resolved({
+          name: true,
+          owner: {
+            name: true,
+          },
+        });
+
+        const dog = Dog.create(
+          {
+            type: "dog",
+            name: "Rex",
+            owner: { name: "Lewis" },
+          },
+          publicGroup,
+        );
+
+        const loadedDiscriminatedUnion = await Pet.load(dog.$jazz.id, {
+          loadAs: clientAccount,
+        });
+
+        assertLoaded(loadedDiscriminatedUnion);
+        expect(loadedDiscriminatedUnion.name.$isLoaded).toBe(true);
+        expect(loadedDiscriminatedUnion.name.toUpperCase()).toBe("REX");
+
+        assert(loadedDiscriminatedUnion.type === "dog");
+        expect(loadedDiscriminatedUnion.owner.name.toUpperCase()).toBe("LEWIS");
+      });
     });
 
     describe("on subscribe()", () => {