jazz-tools 0.15.16 → 0.16.1

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

@@ -52,6 +52,15 @@ describe("CoMap.Record", async () => {
       expect(Object.keys(person)).toEqual(["age"]);
     });
 
+    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;
+      expect(person.name).toEqual("John");
+      expect(person.age).toEqual(null);
+      expect(person.bio).toEqual(null);
+    });
+
     test("property existence", () => {
       const Person = co.record(z.string(), z.string());
 
@@ -236,9 +245,6 @@ describe("CoMap.Record", async () => {
         pet1: Dog.create({ name: "Rex", breed: "Labrador" }),
       });
 
-      type V = (typeof Person)["_zod"]["def"]["valueType"];
-      type T = InstanceOrPrimitiveOfSchema<typeof Person>;
-
       const updates: Loaded<typeof Person, { $each: true }>[] = [];
       const spy = vi.fn((person) => updates.push(person));
 
@@ -301,7 +307,7 @@ describe("CoMap.Record", async () => {
   });
 
   // Covers https://github.com/garden-co/jazz/issues/2385
-  test("create a Record with a discriminated union containing a co.map that uses withHelpers", () => {
+  test("create a Record with a discriminated union containing a co.image", () => {
     const Base = co.map({
       type: z.literal("base"),
       name: z.string(),
@@ -309,8 +315,8 @@ describe("CoMap.Record", async () => {
 
     const IssueRepro = co.map({
       type: z.literal("repro"),
-      catchall: co.map({}).withHelpers((self) => self),
       name: z.string(),
+      image: co.image(),
     });
 
     const PersonRecord = co.record(
@@ -320,8 +326,10 @@ describe("CoMap.Record", async () => {
 
     const person = IssueRepro.create({
       type: "repro",
-      catchall: IssueRepro.def.shape.catchall.create({}),
       name: "John",
+      image: co.image().create({
+        originalSize: [1920, 1080],
+      }),
     });
 
     const record = PersonRecord.create({
@@ -329,7 +337,7 @@ describe("CoMap.Record", async () => {
     });
 
     if (record.john?.type === "repro") {
-      expect(record.john.catchall).toEqual({});
+      expect(record.john.image.originalSize).toEqual([1920, 1080]);
       expect(record.john.name).toEqual("John");
       expect(record.john.type).toEqual("repro");
     }
@@ -342,9 +350,10 @@ describe("CoMap.Record", async () => {
       name: z.string(),
     });
 
+    const Catchall = co.map({}).catchall(z.string());
     const IssueRepro = co.map({
       type: z.literal("repro"),
-      catchall: co.map({}).catchall(z.string()),
+      catchall: Catchall,
       name: z.string(),
     });
 
@@ -355,7 +364,7 @@ describe("CoMap.Record", async () => {
 
     const person = IssueRepro.create({
       type: "repro",
-      catchall: IssueRepro.def.shape.catchall.create({}),
+      catchall: Catchall.create({}),
       name: "John",
     });
 

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

@@ -1,7 +1,7 @@
 import { assert, describe, expectTypeOf, test } from "vitest";
 import { Group, co, z } from "../exports.js";
 import { Account } from "../index.js";
-import { CoListSchema, Loaded } from "../internal.js";
+import { CoMap, Loaded } from "../internal.js";
 
 describe("CoMap", async () => {
   describe("init", () => {
@@ -117,9 +117,10 @@ describe("CoMap", async () => {
     });
 
     test("CoMap create with partially loaded, reference and optional", () => {
+      const Breed = co.map({ type: z.literal("labrador"), value: z.string() });
       const Dog = co.map({
         name: z.string(),
-        breed: co.map({ type: z.literal("labrador"), value: z.string() }),
+        breed: Breed,
       });
       type Dog = co.loaded<typeof Dog>;
 
@@ -131,7 +132,7 @@ describe("CoMap", async () => {
 
       const dog = Dog.create({
         name: "Rex",
-        breed: Dog.def.shape.breed.create({
+        breed: Breed.create({
           type: "labrador",
           value: "Labrador",
         }),
@@ -158,8 +159,8 @@ describe("CoMap", async () => {
 
     test("Comap with recursive optional reference", () => {
       const Recursive = co.map({
-        get child(): z.ZodOptional<typeof Recursive> {
-          return co.optional(Recursive);
+        get child() {
+          return Recursive.optional();
         },
       });
 
@@ -183,8 +184,7 @@ describe("CoMap", async () => {
       const Person = co.map({
         name: z.string(),
         age: z.number(),
-        // TODO: would be nice if this didn't need a type annotation
-        get friend(): z.ZodOptional<typeof Person> {
+        get friend() {
           return co.optional(Person);
         },
       });
@@ -243,7 +243,7 @@ describe("CoMap", async () => {
     test("update a reference on a loaded value", () => {
       const Dog = co.map({
         name: z.string(),
-        get siblings(): CoListSchema<typeof Dog> {
+        get siblings() {
           return co.list(Dog);
         },
       });
@@ -408,4 +408,32 @@ describe("CoMap resolution", async () => {
       | null
     >();
   });
+
+  test("loading a map with a nullable field", async () => {
+    const Dog = co.map({
+      name: z.string(),
+      breed: z.string(),
+    });
+    const Person = co.map({
+      name: z.string(),
+      age: z.number().nullable(),
+      dog: Dog,
+    });
+
+    const person = Person.create({
+      name: "John",
+      age: 20,
+      dog: Dog.create({ name: "Rex", breed: "Labrador" }),
+    });
+
+    const loadedPerson = await Person.load(person.id);
+
+    expectTypeOf(loadedPerson!).toEqualTypeOf<
+      {
+        name: string;
+        age: number | null;
+        dog: Loaded<typeof Dog> | null;
+      } & CoMap
+    >();
+  });
 });

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

@@ -12,7 +12,7 @@ import {
 } from "vitest";
 import { Group, co, subscribeToCoValue, z } from "../exports.js";
 import { Account } from "../index.js";
-import { Loaded, anySchemaToCoSchema } from "../internal.js";
+import { Loaded, coValueClassFromCoValueClassOrSchema } from "../internal.js";
 import {
   createJazzTestAccount,
   getPeerConnectedToTestSyncServer,
@@ -143,8 +143,7 @@ describe("CoMap", async () => {
       const Person = co.map({
         name: z.string(),
         age: z.number(),
-        // TODO: would be nice if this didn't need a type annotation
-        get friend(): z.ZodOptional<typeof Person> {
+        get friend() {
           return co.optional(Person);
         },
       });
@@ -181,7 +180,7 @@ describe("CoMap", async () => {
       const Person = co.map({
         name: z.string(),
         age: z.number(),
-        get friend(): z.ZodOptional<typeof Person> {
+        get friend(): co.Optional<typeof Person> {
           return co.optional(Person);
         },
       });
@@ -210,7 +209,7 @@ describe("CoMap", async () => {
       const Person = co.map({
         name: z.string(),
         age: z.number(),
-        get friend(): z.ZodOptional<typeof Person> {
+        get friend(): co.Optional<typeof Person> {
           return co.optional(Person);
         },
       });
@@ -291,6 +290,74 @@ describe("CoMap", async () => {
         age: 30,
       });
     });
+
+    it("should allow extra properties when catchall is provided", () => {
+      const Person = co
+        .map({
+          name: z.string(),
+          age: z.number(),
+        })
+        .catchall(z.string());
+
+      const person = Person.create({ name: "John", age: 20 });
+      expect(person.name).toEqual("John");
+      expect(person.age).toEqual(20);
+      expect(person.extra).toBeUndefined();
+
+      person.name = "Jane";
+      person.age = 28;
+      person.extra = "extra";
+
+      expect(person.name).toEqual("Jane");
+      expect(person.age).toEqual(28);
+      expect(person.extra).toEqual("extra");
+    });
+
+    test("CoMap with reference can be created with a shallowly resolved reference", async () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+      const Person = co.map({
+        name: z.string(),
+        age: z.number(),
+        pet: Dog,
+        get friend() {
+          return Person.optional();
+        },
+      });
+
+      const group = Group.create();
+      group.addMember("everyone", "writer");
+
+      const pet = Dog.create({ name: "Rex", breed: "Labrador" }, group);
+      const personA = Person.create(
+        {
+          name: "John",
+          age: 20,
+          pet,
+        },
+        { owner: group },
+      );
+
+      const userB = await createJazzTestAccount();
+      const loadedPersonA = await Person.load(personA.id, {
+        resolve: true,
+        loadAs: userB,
+      });
+
+      expect(loadedPersonA).not.toBeNull();
+      assert(loadedPersonA);
+
+      const personB = Person.create({
+        name: "Jane",
+        age: 28,
+        pet,
+        friend: loadedPersonA,
+      });
+
+      expect(personB.friend?.pet.name).toEqual("Rex");
+    });
   });
 
   describe("Mutation", () => {
@@ -801,7 +868,7 @@ describe("CoMap resolution", async () => {
     const spy = vi.fn((person) => updates.push(person));
 
     subscribeToCoValue(
-      anySchemaToCoSchema(Person), // TODO: we should get rid of the conversion in the future
+      coValueClassFromCoValueClassOrSchema(Person), // TODO: we should get rid of the conversion in the future
       person.id,
       {
         syncResolution: true,
@@ -2104,6 +2171,20 @@ describe("CoMap migration", () => {
   });
 });
 
+describe("co.map schema", () => {
+  test("can access the inner schemas of a co.map", () => {
+    const Person = co.map({
+      name: co.plainText(),
+    });
+
+    const person = Person.create({
+      name: Person.shape["name"].create("John"),
+    });
+
+    expect(person.name.toString()).toEqual("John");
+  });
+});
+
 describe("Updating a nested reference", () => {
   test("should assign a resolved optional reference and expect value is not null", async () => {
     // Define the schema similar to the server-worker-http example

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

@@ -1,4 +1,4 @@
-import { beforeEach, describe, test } from "vitest";
+import { beforeEach, describe, expect, test } from "vitest";
 import { CoPlainText, co, z } from "../exports.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 
@@ -36,4 +36,66 @@ describe("co.optional", () => {
       preferredName: co.optional(z.string()),
     });
   });
+
+  test("can use schem.optional() on all CoValue schemas but co.optional()", () => {
+    const Option1 = co.map({ type: z.literal("1") });
+    const Option2 = co.map({ type: z.literal("2") });
+    const Schema = co.map({
+      plainText: co.plainText().optional(),
+      richText: co.richText().optional(),
+      fileStream: co.fileStream().optional(),
+      image: co.image().optional(),
+      record: co.record(z.string(), z.string()).optional(),
+      map: co.map({ field: z.string() }).optional(),
+      list: co.list(z.string()).optional(),
+      feed: co.feed(z.string()).optional(),
+      union: co.discriminatedUnion("type", [Option1, Option2]).optional(),
+    });
+
+    const schema = Schema.create({});
+
+    expect(schema.plainText).toBeUndefined();
+    expect(schema.richText).toBeUndefined();
+    expect(schema.fileStream).toBeUndefined();
+    expect(schema.image).toBeUndefined();
+    expect(schema.record).toBeUndefined();
+    expect(schema.map).toBeUndefined();
+    expect(schema.list).toBeUndefined();
+    expect(schema.feed).toBeUndefined();
+    expect(schema.union).toBeUndefined();
+
+    schema.plainText = Schema.shape.plainText.innerType.create("Hello");
+    schema.richText = Schema.shape.richText.innerType.create("Hello");
+    schema.fileStream = Schema.shape.fileStream.innerType.create();
+    schema.image = Schema.shape.image.innerType.create({
+      originalSize: [1920, 1080],
+    });
+    schema.record = Schema.shape.record.innerType.create({ field: "hello" });
+    schema.map = Schema.shape.map.innerType.create({ field: "hello" });
+    schema.list = Schema.shape.list.innerType.create([]);
+    schema.feed = Schema.shape.feed.innerType.create([]);
+    schema.union = Option1.create({ type: "1" });
+
+    expect(schema.plainText?.toString()).toEqual("Hello");
+    expect(schema.richText?.toString()).toEqual("Hello");
+    expect(schema.fileStream).not.toBeUndefined();
+    expect(schema.image?.originalSize).toEqual([1920, 1080]);
+    expect(schema.record?.field).toEqual("hello");
+    expect(schema.map?.field).toEqual("hello");
+    expect(schema.list).toEqual([]);
+    expect(schema.feed).not.toBeUndefined();
+    expect(schema.union?.type).toEqual("1");
+  });
+
+  test("can access the inner schema of a co.optional", () => {
+    const Person = co.map({
+      preferredName: co.optional(co.plainText()),
+    });
+
+    const person = Person.create({
+      preferredName: Person.shape["preferredName"].innerType.create("John"),
+    });
+
+    expect(person?.preferredName?.toString()).toEqual("John");
+  });
 });

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

@@ -9,15 +9,13 @@ import {
   ID,
   InMemoryKVStore,
   KvStoreContext,
-  anySchemaToCoSchema,
   co,
+  coValueClassFromCoValueClassOrSchema,
   createAnonymousJazzContext,
   createJazzContext,
   createJazzContextForNewAccount,
   createJazzContextFromExistingCredentials,
   randomSessionProvider,
-  z,
-  zodSchemaToCoSchema,
 } from "../exports";
 import { activeAccountContext } from "../implementation/activeAccountContext";
 import {
@@ -86,12 +84,12 @@ describe("createContext methods", () => {
         credentials,
         peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
         crypto: Crypto,
-        AccountSchema: zodSchemaToCoSchema(CustomAccount),
+        AccountSchema: CustomAccount,
         sessionProvider: randomSessionProvider,
       });
 
       expect(context.account).toBeInstanceOf(
-        anySchemaToCoSchema(CustomAccount),
+        coValueClassFromCoValueClassOrSchema(CustomAccount),
       );
     });
 
@@ -196,11 +194,11 @@ describe("createContext methods", () => {
         creationProps: { name: "New User" },
         peersToLoadFrom: [],
         crypto: Crypto,
-        AccountSchema: zodSchemaToCoSchema(CustomAccount),
+        AccountSchema: CustomAccount,
       });
 
       expect(context.account).toBeInstanceOf(
-        anySchemaToCoSchema(CustomAccount),
+        coValueClassFromCoValueClassOrSchema(CustomAccount),
       );
     });
 
@@ -347,11 +345,11 @@ describe("createContext methods", () => {
         crypto: Crypto,
         authSecretStorage,
         sessionProvider: randomSessionProvider,
-        AccountSchema: zodSchemaToCoSchema(CustomAccount),
+        AccountSchema: CustomAccount,
       });
 
       expect(context.account).toBeInstanceOf(
-        anySchemaToCoSchema(CustomAccount),
+        coValueClassFromCoValueClassOrSchema(CustomAccount),
       );
     });
   });

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

@@ -1,4 +1,4 @@
-import { Profile, cojsonInternals } from "cojson";
+import { cojsonInternals } from "cojson";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { assert, describe, expect, expectTypeOf, test, vi } from "vitest";
 import {
@@ -9,13 +9,7 @@ import {
   isControlledAccount,
   z,
 } from "../index.js";
-import {
-  Account,
-  CoListSchema,
-  Loaded,
-  co,
-  randomSessionProvider,
-} from "../internal.js";
+import { Account, Loaded, co, randomSessionProvider } from "../internal.js";
 import { createJazzTestAccount, linkAccounts } from "../testing.js";
 import { waitFor } from "./utils.js";
 
@@ -794,11 +788,11 @@ describe("Deep loading with unauthorized account", async () => {
   test("unaccessible list element with $onError and $each with depth", async () => {
     const Person = co.map({
       name: z.string(),
-      get friends(): z.ZodOptional<typeof Friends> {
+      get friends(): co.Optional<typeof Friends> {
         return co.optional(Friends);
       },
     });
-    const Friends: CoListSchema<typeof Person> = co.list(Person); // TODO: annoying that we have to annotate
+    const Friends: co.List<typeof Person> = co.list(Person); // TODO: annoying that we have to annotate
 
     const list = Friends.create(
       [

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

@@ -464,13 +464,13 @@ describe("importContentPieces", () => {
       {
         title: "My First Post",
         content: "Hello World",
-        comments: Post.def.shape.comments.create([comment1, comment2], group),
+        comments: Post.shape.comments.create([comment1, comment2], group),
       },
       group,
     );
 
     const blog = Blog.create(
-      { name: "My Blog", posts: Blog.def.shape.posts.create([post], group) },
+      { name: "My Blog", posts: Blog.shape.posts.create([post], group) },
       group,
     );
 

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

@@ -1,7 +1,7 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import { CoMap, Group, z } from "../exports.js";
-import { Loaded, Ref, co, zodSchemaToCoSchema } from "../internal.js";
+import { Loaded, Ref, co } from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { setupTwoNodes, waitFor } from "./utils.js";
 
@@ -22,15 +22,16 @@ describe("Custom accounts and groups", async () => {
       color: z.string(),
     });
 
+    const Root = co.map({});
     const CustomAccount = co
       .account({
         profile: CustomProfile,
-        root: co.map({}),
+        root: Root,
       })
       .withMigration((account, creationProps?: { name: string }) => {
         // making sure that the inferred type of account.root & account.profile considers the root/profile not being loaded
         type R = typeof account.root;
-        const _r: R = {} as Loaded<typeof CustomAccount.def.shape.root> | null;
+        const _r: R = {} as Loaded<typeof Root> | null;
         type P = typeof account.profile;
         const _p: P = {} as Loaded<typeof CustomProfile> | null;
         if (creationProps) {
@@ -47,7 +48,7 @@ describe("Custom accounts and groups", async () => {
     const me = await createJazzTestAccount({
       creationProps: { name: "Hermes Puggington" },
       isCurrentActiveAccount: true,
-      AccountSchema: zodSchemaToCoSchema(CustomAccount),
+      AccountSchema: CustomAccount,
     });
 
     expect(me.profile).toBeDefined();

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

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 import { Group, Inbox, InboxSender, z } from "../exports";
-import { Loaded, anySchemaToCoSchema, co } from "../internal";
+import { Loaded, co, coValueClassFromCoValueClassOrSchema } from "../internal";
 import { setupTwoNodes, waitFor } from "./utils";
 
 const Message = co.map({
@@ -18,7 +18,8 @@ describe("Inbox", () => {
 
       const { clientAccount: sender, serverAccount: receiver } =
         await setupTwoNodes({
-          ServerAccountSchema: anySchemaToCoSchema(WorkerAccount),
+          ServerAccountSchema:
+            coValueClassFromCoValueClassOrSchema(WorkerAccount),
         });
 
       await expect(() => InboxSender.load(receiver.id, sender)).rejects.toThrow(

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

@@ -69,33 +69,6 @@ test("load a missing optional value (co.optional)", async () => {
   expect(john.dog).toBeUndefined();
 });
 
-test("load a missing optional value (z.optional)", async () => {
-  const Dog = co.map({
-    name: z.string(),
-  });
-
-  const Person = co.map({
-    name: z.string(),
-    dog: z.optional(Dog),
-  });
-
-  const group = Group.create();
-  const map = Person.create({ name: "John" }, group);
-  group.addMember("everyone", "reader");
-
-  const alice = await createJazzTestAccount();
-
-  const john = await Person.load(map.id, {
-    loadAs: alice,
-    resolve: { dog: true },
-  });
-
-  assert(john);
-
-  expect(john.name).toBe("John");
-  expect(john.dog).toBeUndefined();
-});
-
 test("load a missing optional value (Schema.optional)", async () => {
   const Dog = co.map({
     name: z.string(),
@@ -214,13 +187,14 @@ test("returns null if the value is unavailable after retries", async () => {
 test("load a large coValue", async () => {
   const syncServer = await setupJazzTestSync({ asyncPeers: true });
 
+  const Data = co.list(z.string());
   const LargeDataset = co.map({
     metadata: z.object({
       name: z.string(),
       description: z.string(),
       createdAt: z.number(),
     }),
-    data: co.list(z.string()),
+    data: Data,
   });
 
   const group = Group.create(syncServer);
@@ -232,7 +206,7 @@ test("load a large coValue", async () => {
           "A dataset with many entries for testing large coValue loading",
         createdAt: Date.now(),
       },
-      data: LargeDataset.def.shape.data.create([], group),
+      data: Data.create([], group),
     },
     group,
   );

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

@@ -4,8 +4,8 @@ import {
   Account,
   CryptoProvider,
   Loaded,
-  anySchemaToCoSchema,
   co,
+  coValueClassFromCoValueClassOrSchema,
   subscribeToCoValue,
   z,
 } from "../exports.js";
@@ -93,7 +93,7 @@ describe("SchemaUnion", () => {
     );
     let currentValue = "Submit";
     const unsubscribe = subscribeToCoValue(
-      anySchemaToCoSchema(WidgetUnion),
+      coValueClassFromCoValueClassOrSchema(WidgetUnion),
       buttonWidget.id,
       { loadAs: me, syncResolution: true },
       (value: Loaded<typeof WidgetUnion>) => {