jazz-tools 0.14.5 → 0.14.6

package/src/tests/coFeed.test.ts

@@ -2,18 +2,14 @@ import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { describe, expect, expectTypeOf, test } from "vitest";
 import {
   Account,
-  CoFeed,
   FileStream,
   Group,
-  ID,
   co,
-  coField,
   cojsonInternals,
   isControlledAccount,
   z,
 } from "../index.js";
 import {
-  AnyCoFeedSchema,
   Loaded,
   createJazzContextFromExistingCredentials,
   randomSessionProvider,
@@ -350,23 +346,50 @@ describe("Simple FileStream operations", async () => {
 
   const stream = FileStream.create({ owner: me });
 
-  test("Construction", () => {
-    expect(stream.getChunks()).toBe(undefined);
+  describe("FileStream", () => {
+    test("Construction", () => {
+      expect(stream.getChunks()).toBe(undefined);
+    });
+
+    test("Mutation", () => {
+      stream.start({ mimeType: "text/plain" });
+      stream.push(new Uint8Array([1, 2, 3]));
+      stream.push(new Uint8Array([4, 5, 6]));
+      stream.end();
+
+      const chunks = stream.getChunks();
+      expect(chunks?.mimeType).toBe("text/plain");
+      expect(chunks?.chunks).toEqual([
+        new Uint8Array([1, 2, 3]),
+        new Uint8Array([4, 5, 6]),
+      ]);
+      expect(chunks?.finished).toBe(true);
+    });
   });
 
-  test("Mutation", () => {
-    stream.start({ mimeType: "text/plain" });
-    stream.push(new Uint8Array([1, 2, 3]));
-    stream.push(new Uint8Array([4, 5, 6]));
-    stream.end();
+  describe("co.fileStream", () => {
+    const fs = co.fileStream().create({ owner: me });
 
-    const chunks = stream.getChunks();
-    expect(chunks?.mimeType).toBe("text/plain");
-    expect(chunks?.chunks).toEqual([
-      new Uint8Array([1, 2, 3]),
-      new Uint8Array([4, 5, 6]),
-    ]);
-    expect(chunks?.finished).toBe(true);
+    test("Construction", () => {
+      expect(fs.getChunks()).toBe(undefined);
+    });
+
+    test("Type compatibility", () => {
+      // Check base functionality works
+      expectTypeOf(co.fileStream()).toHaveProperty("create");
+
+      // We can acknowledge the type error exists
+      // This is a runtime test that verifies that despite the TypeScript error,
+      // the functionality still works as expected
+      expect(typeof fs.getChunks).toBe("function");
+    });
+
+    test("Mutation", () => {
+      fs.start({ mimeType: "text/plain" });
+      fs.push(new Uint8Array([1, 2, 3]));
+      fs.push(new Uint8Array([4, 5, 6]));
+      fs.end();
+    });
   });
 });
 

package/src/tests/coList.test-d.ts

@@ -0,0 +1,245 @@
+import { assert, describe, expectTypeOf, test } from "vitest";
+import { Group, co, z } from "../exports.js";
+import { Account } from "../index.js";
+import { Loaded } from "../internal.js";
+
+describe("CoList", () => {
+  describe("init", () => {
+    test("create a CoList with basic property access", () => {
+      const StringList = co.list(z.string());
+
+      const list = StringList.create(["a", "b", "c"]);
+
+      type ExpectedType = string[];
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(list);
+    });
+
+    test("has the _owner property", () => {
+      const StringList = co.list(z.string());
+
+      const list = StringList.create(["a", "b", "c"], Account.getMe());
+
+      expectTypeOf(list._owner).toEqualTypeOf<Account | Group>();
+    });
+
+    test("CoList with reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const DogList = co.list(Dog);
+
+      const list = DogList.create([
+        Dog.create({ name: "Rex", breed: "Labrador" }),
+        Dog.create({ name: "Fido", breed: "Poodle" }),
+        // @ts-expect-error - undefined is not a valid argument
+        undefined,
+      ]);
+
+      type ExpectedType = Loaded<typeof Dog>[];
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(list);
+    });
+
+    test("CoList with optional reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const DogList = co.list(Dog.optional());
+
+      const list = DogList.create([
+        Dog.create({ name: "Rex", breed: "Labrador" }),
+        undefined,
+      ]);
+
+      type ExpectedType = (Loaded<typeof Dog> | undefined)[];
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(list);
+    });
+
+    test("CoList create with partially loaded, reference and optional", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+      });
+      type Dog = co.loaded<typeof Dog>;
+
+      const DogList = co.list(Dog.optional());
+
+      const dog = Dog.create({
+        name: "Rex",
+        breed: Dog.def.shape.breed.create({
+          type: "labrador",
+          value: "Labrador",
+        }),
+      }) as Dog;
+
+      const list = DogList.create([dog, undefined]);
+
+      type ExpectedType = (Loaded<typeof Dog> | undefined)[];
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(list);
+    });
+
+    test("CoList with nested lists", () => {
+      const NestedList = co.list(co.list(z.string()));
+
+      const list = NestedList.create([
+        co.list(z.string()).create(["a", "b"]),
+        co.list(z.string()).create(["c", "d"]),
+      ]);
+
+      type ExpectedType = string[][];
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(list);
+    });
+
+    test("CoList with enum type", () => {
+      const EnumList = co.list(z.enum(["a", "b", "c"]));
+
+      const list = EnumList.create(["a", "b", "c"]);
+
+      type ExpectedType = ("a" | "b" | "c")[];
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(list);
+    });
+  });
+
+  describe("CoList resolution", () => {
+    test("loading a list with deep resolve", async () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const DogList = co.list(Dog);
+
+      const list = DogList.create([
+        Dog.create({ name: "Rex", breed: "Labrador" }),
+        Dog.create({ name: "Fido", breed: "Poodle" }),
+      ]);
+
+      const loadedList = await DogList.load(list.id, {
+        resolve: {
+          $each: true,
+        },
+      });
+
+      type ExpectedType = Loaded<typeof Dog>[] | null;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(loadedList);
+
+      assert(loadedList);
+      const firstDog = loadedList[0];
+      assert(firstDog);
+      expectTypeOf(firstDog.name).toEqualTypeOf<string>();
+    });
+
+    test("loading a list with $onError", async () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const DogList = co.list(Dog);
+
+      const list = DogList.create([
+        Dog.create({ name: "Rex", breed: "Labrador" }),
+        Dog.create({ name: "Fido", breed: "Poodle" }),
+      ]);
+
+      const loadedList = await DogList.load(list.id, {
+        resolve: {
+          $each: { $onError: null },
+        },
+      });
+
+      type ExpectedType =
+        | (
+            | (Loaded<typeof Dog> & {
+                $onError: never;
+              })
+            | null
+          )[]
+        | null;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(loadedList);
+    });
+
+    test("loading a nested list with deep resolve", async () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const DogList = co.list(Dog);
+      const NestedList = co.list(DogList);
+
+      const list = NestedList.create([
+        DogList.create([
+          Dog.create({ name: "Rex", breed: "Labrador" }),
+          Dog.create({ name: "Fido", breed: "Poodle" }),
+        ]),
+      ]);
+
+      const loadedList = await NestedList.load(list.id, {
+        resolve: {
+          $each: {
+            $each: true,
+          },
+        },
+      });
+
+      type ExpectedType = Loaded<typeof Dog>[][] | null;
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(loadedList);
+
+      assert(loadedList);
+      const firstList = loadedList[0];
+      assert(firstList);
+      const firstDog = firstList[0];
+      assert(firstDog);
+      expectTypeOf(firstDog.name).toEqualTypeOf<string>();
+    });
+  });
+});

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

@@ -79,6 +79,39 @@ describe("CoMap.Record", () => {
 
       matches(person);
     });
+
+    test("Record create with partially loaded, reference and optional", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+      });
+      type Dog = co.loaded<typeof Dog>;
+
+      const DogRecord = co.record(z.string(), Dog.optional());
+
+      const dog = Dog.create({
+        name: "Rex",
+        breed: Dog.def.shape.breed.create({
+          type: "labrador",
+          value: "Labrador",
+        }),
+      }) as Dog;
+
+      const record = DogRecord.create({
+        pet1: dog,
+        pet2: undefined,
+      });
+
+      type ExpectedType = {
+        [key: string]: Loaded<typeof Dog> | undefined;
+      };
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(record);
+    });
   });
 
   describe("Record resolution", () => {

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

@@ -1,13 +1,7 @@
 import { assert, describe, expectTypeOf, test } from "vitest";
 import { Group, co, z } from "../exports.js";
 import { Account } from "../index.js";
-import {
-  CoListSchema,
-  CoMapInitZod,
-  Loaded,
-  optionalKeys,
-  requiredKeys,
-} from "../internal.js";
+import { CoListSchema, Loaded } from "../internal.js";
 
 describe("CoMap", async () => {
   describe("init", () => {
@@ -143,10 +137,6 @@ describe("CoMap", async () => {
         }),
       }) as Dog;
 
-      type R = requiredKeys<typeof Person.def.shape>;
-      type O = optionalKeys<typeof Person.def.shape>;
-      type I = CoMapInitZod<typeof Person.def.shape>;
-
       const person = Person.create({
         name: "John",
         age: 20,