jazz-tools 0.16.0 → 0.16.1

package/src/tools/implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchema.ts

@@ -41,12 +41,11 @@ export type InstanceOrPrimitiveOfSchema<
             -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
               Shape[key]
             >;
-          } & (unknown extends CatchAll
-            ? {}
-            : {
-                // @ts-expect-error
+          } & (CatchAll extends AnyZodOrCoValueSchema
+            ? {
                 [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
-              }) &
+              }
+            : {}) &
             CoMap
         : S extends CoreCoListSchema<infer T>
           ? CoList<InstanceOrPrimitiveOfSchema<T>>
@@ -66,56 +65,58 @@ export type InstanceOrPrimitiveOfSchema<
   : S extends z.core.$ZodType
     ? S extends z.core.$ZodOptional<infer Inner extends z.core.$ZodType>
       ? InstanceOrPrimitiveOfSchema<Inner> | undefined
-      : S extends z.ZodJSONSchema
-        ? JsonValue
-        : S extends z.core.$ZodUnion<infer Members extends z.core.$ZodType[]>
-          ? InstanceOrPrimitiveOfSchema<Members[number]>
-          : // primitives below here - we manually traverse to ensure we only allow what we can handle
-            S extends z.core.$ZodObject<infer Shape>
-            ? {
-                -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
-                  Shape[key]
-                >;
-              }
-            : S extends z.core.$ZodArray<infer Item extends z.core.$ZodType>
-              ? InstanceOrPrimitiveOfSchema<Item>[]
-              : S extends z.core.$ZodTuple<
-                    infer Items extends readonly z.core.$ZodType[]
-                  >
-                ? {
-                    [key in keyof Items]: InstanceOrPrimitiveOfSchema<
-                      Items[key]
-                    >;
-                  }
-                : S extends z.core.$ZodString
-                  ? string
-                  : S extends z.core.$ZodNumber
-                    ? number
-                    : S extends z.core.$ZodBoolean
-                      ? boolean
-                      : S extends z.core.$ZodLiteral<infer Literal>
-                        ? Literal
-                        : S extends z.core.$ZodDate
-                          ? Date
-                          : S extends z.core.$ZodEnum<infer Enum>
-                            ? Enum[keyof Enum]
-                            : S extends z.core.$ZodTemplateLiteral<
-                                  infer pattern
-                                >
-                              ? pattern
-                              : S extends z.core.$ZodReadonly<
-                                    infer Inner extends z.core.$ZodType
+      : S extends z.core.$ZodNullable<infer Inner extends z.core.$ZodType>
+        ? InstanceOrPrimitiveOfSchema<Inner> | null
+        : S extends z.ZodJSONSchema
+          ? JsonValue
+          : S extends z.core.$ZodUnion<infer Members extends z.core.$ZodType[]>
+            ? InstanceOrPrimitiveOfSchema<Members[number]>
+            : // primitives below here - we manually traverse to ensure we only allow what we can handle
+              S extends z.core.$ZodObject<infer Shape>
+              ? {
+                  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+                    Shape[key]
+                  >;
+                }
+              : S extends z.core.$ZodArray<infer Item extends z.core.$ZodType>
+                ? InstanceOrPrimitiveOfSchema<Item>[]
+                : S extends z.core.$ZodTuple<
+                      infer Items extends readonly z.core.$ZodType[]
+                    >
+                  ? {
+                      [key in keyof Items]: InstanceOrPrimitiveOfSchema<
+                        Items[key]
+                      >;
+                    }
+                  : S extends z.core.$ZodString
+                    ? string
+                    : S extends z.core.$ZodNumber
+                      ? number
+                      : S extends z.core.$ZodBoolean
+                        ? boolean
+                        : S extends z.core.$ZodLiteral<infer Literal>
+                          ? Literal
+                          : S extends z.core.$ZodDate
+                            ? Date
+                            : S extends z.core.$ZodEnum<infer Enum>
+                              ? Enum[keyof Enum]
+                              : S extends z.core.$ZodTemplateLiteral<
+                                    infer pattern
                                   >
-                                ? InstanceOrPrimitiveOfSchema<Inner>
-                                : S extends z.core.$ZodDefault<
-                                      infer Default extends z.core.$ZodType
+                                ? pattern
+                                : S extends z.core.$ZodReadonly<
+                                      infer Inner extends z.core.$ZodType
                                     >
-                                  ? InstanceOrPrimitiveOfSchema<Default>
-                                  : S extends z.core.$ZodCatch<
-                                        infer Catch extends z.core.$ZodType
+                                  ? InstanceOrPrimitiveOfSchema<Inner>
+                                  : S extends z.core.$ZodDefault<
+                                        infer Default extends z.core.$ZodType
                                       >
-                                    ? InstanceOrPrimitiveOfSchema<Catch>
-                                    : never
+                                    ? InstanceOrPrimitiveOfSchema<Default>
+                                    : S extends z.core.$ZodCatch<
+                                          infer Catch extends z.core.$ZodType
+                                        >
+                                      ? InstanceOrPrimitiveOfSchema<Catch>
+                                      : never
     : S extends CoValueClass
       ? InstanceType<S>
       : never;

package/src/tools/implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.ts

@@ -49,13 +49,13 @@ export type InstanceOrPrimitiveOfSchemaCoValuesNullable<
                 -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
                   Shape[key]
                 >;
-              } & (unknown extends CatchAll
-                ? {}
-                : {
+              } & (CatchAll extends AnyZodOrCoValueSchema
+                ? {
                     [
-                      key: string // @ts-expect-error
+                      key: string
                     ]: InstanceOrPrimitiveOfSchemaCoValuesNullable<CatchAll>;
-                  }) &
+                  }
+                : {}) &
                 CoMap)
             | null
         : S extends CoreCoListSchema<infer T>
@@ -78,58 +78,60 @@ export type InstanceOrPrimitiveOfSchemaCoValuesNullable<
   : S extends z.core.$ZodType
     ? S extends z.core.$ZodOptional<infer Inner extends z.core.$ZodType>
       ? InstanceOrPrimitiveOfSchemaCoValuesNullable<Inner> | undefined
-      : S extends z.ZodJSONSchema
-        ? JsonValue
-        : S extends z.core.$ZodUnion<
-              infer Members extends readonly z.core.$ZodType[]
-            >
-          ? InstanceOrPrimitiveOfSchemaCoValuesNullable<Members[number]>
-          : // primitives below here - we manually traverse to ensure we only allow what we can handle
-            S extends z.core.$ZodObject<infer Shape>
-            ? {
-                -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
-                  Shape[key]
-                >;
-              }
-            : S extends z.core.$ZodArray<infer Item extends z.core.$ZodType>
-              ? InstanceOrPrimitiveOfSchema<Item>[]
-              : S extends z.core.$ZodTuple<
-                    infer Items extends z.core.$ZodType[]
-                  >
-                ? {
-                    [key in keyof Items]: InstanceOrPrimitiveOfSchema<
-                      Items[key]
-                    >;
-                  }
-                : S extends z.core.$ZodString
-                  ? string
-                  : S extends z.core.$ZodNumber
-                    ? number
-                    : S extends z.core.$ZodBoolean
-                      ? boolean
-                      : S extends z.core.$ZodLiteral<infer Literal>
-                        ? Literal
-                        : S extends z.core.$ZodDate
-                          ? Date
-                          : S extends z.core.$ZodEnum<infer Enum>
-                            ? Enum[keyof Enum]
-                            : S extends z.core.$ZodTemplateLiteral<
-                                  infer pattern
-                                >
-                              ? pattern
-                              : S extends z.core.$ZodReadonly<
-                                    infer Inner extends z.core.$ZodType
+      : S extends z.core.$ZodNullable<infer Inner extends z.core.$ZodType>
+        ? InstanceOrPrimitiveOfSchemaCoValuesNullable<Inner> | null
+        : S extends z.ZodJSONSchema
+          ? JsonValue
+          : S extends z.core.$ZodUnion<
+                infer Members extends readonly z.core.$ZodType[]
+              >
+            ? InstanceOrPrimitiveOfSchemaCoValuesNullable<Members[number]>
+            : // primitives below here - we manually traverse to ensure we only allow what we can handle
+              S extends z.core.$ZodObject<infer Shape>
+              ? {
+                  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+                    Shape[key]
+                  >;
+                }
+              : S extends z.core.$ZodArray<infer Item extends z.core.$ZodType>
+                ? InstanceOrPrimitiveOfSchema<Item>[]
+                : S extends z.core.$ZodTuple<
+                      infer Items extends z.core.$ZodType[]
+                    >
+                  ? {
+                      [key in keyof Items]: InstanceOrPrimitiveOfSchema<
+                        Items[key]
+                      >;
+                    }
+                  : S extends z.core.$ZodString
+                    ? string
+                    : S extends z.core.$ZodNumber
+                      ? number
+                      : S extends z.core.$ZodBoolean
+                        ? boolean
+                        : S extends z.core.$ZodLiteral<infer Literal>
+                          ? Literal
+                          : S extends z.core.$ZodDate
+                            ? Date
+                            : S extends z.core.$ZodEnum<infer Enum>
+                              ? Enum[keyof Enum]
+                              : S extends z.core.$ZodTemplateLiteral<
+                                    infer pattern
                                   >
-                                ? InstanceOrPrimitiveOfSchema<Inner>
-                                : S extends z.core.$ZodDefault<
-                                      infer Default extends z.core.$ZodType
+                                ? pattern
+                                : S extends z.core.$ZodReadonly<
+                                      infer Inner extends z.core.$ZodType
                                     >
-                                  ? InstanceOrPrimitiveOfSchema<Default>
-                                  : S extends z.core.$ZodCatch<
-                                        infer Catch extends z.core.$ZodType
+                                  ? InstanceOrPrimitiveOfSchema<Inner>
+                                  : S extends z.core.$ZodDefault<
+                                        infer Default extends z.core.$ZodType
                                       >
-                                    ? InstanceOrPrimitiveOfSchema<Catch>
-                                    : never
+                                    ? InstanceOrPrimitiveOfSchema<Default>
+                                    : S extends z.core.$ZodCatch<
+                                          infer Catch extends z.core.$ZodType
+                                        >
+                                      ? InstanceOrPrimitiveOfSchema<Catch>
+                                      : never
     : S extends CoValueClass
       ? InstanceType<S> | null
       : never;

package/src/tools/implementation/zodSchema/zodCo.ts

@@ -108,7 +108,7 @@ export const coListDefiner = <T extends AnyZodOrCoValueSchema>(
   element: T,
 ): CoListSchema<T> => {
   const coreSchema = createCoreCoListSchema(element);
-  return hydrateCoreCoValueSchema(coreSchema) as unknown as CoListSchema<T>;
+  return hydrateCoreCoValueSchema(coreSchema);
 };
 
 export const coProfileDefiner = <
@@ -121,7 +121,7 @@ export const coProfileDefiner = <
     inbox: z.optional(z.string()),
     inboxInvite: z.optional(z.string()),
   });
-  return coMapDefiner(ehnancedShape) as CoProfileSchema<Shape>;
+  return coMapDefiner(ehnancedShape) as unknown as CoProfileSchema<Shape>;
 };
 
 export const coFeedDefiner = <T extends AnyZodOrCoValueSchema>(

package/src/tools/implementation/zodSchema/zodSchema.ts

@@ -24,8 +24,8 @@ import {
 import { CoFeedSchema, CoreCoFeedSchema } from "./schemaTypes/CoFeedSchema.js";
 import { CoListSchema, CoreCoListSchema } from "./schemaTypes/CoListSchema.js";
 import {
-  CoMapInitZod,
   CoMapSchema,
+  CoMapSchemaInit,
   CoreCoMapSchema,
 } from "./schemaTypes/CoMapSchema.js";
 import {
@@ -126,5 +126,5 @@ export type ResolveQueryStrict<
 export type InitFor<T extends CoValueClassOrSchema> = T extends CoreCoMapSchema<
   infer Shape
 >
-  ? Simplify<CoMapInitZod<Shape>>
+  ? Simplify<CoMapSchemaInit<Shape>>
   : never;

package/src/tools/lib/utilityTypes.ts

@@ -1,3 +1,12 @@
+/**
+ * Make any property optional if its type includes `undefined`, preserving the type as-is
+ */
+export type PartialOnUndefined<T> = {
+  [K in keyof T as undefined extends T[K] ? never : K]: T[K];
+} & {
+  [K in keyof T as undefined extends T[K] ? K : never]?: T[K];
+};
+
 /**
  * Useful to flatten the type output to improve type hints shown in editors.
  * And also to transform an interface into a type to aide with assignability.

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

@@ -13,15 +13,9 @@ import {
   FileStream,
   Group,
   co,
-  cojsonInternals,
   isControlledAccount,
   z,
 } from "../index.js";
-import {
-  Loaded,
-  createJazzContextFromExistingCredentials,
-  randomSessionProvider,
-} from "../internal.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
 
@@ -58,6 +52,14 @@ describe("Simple CoFeed operations", async () => {
     expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
   });
 
+  test("Construction with nullable values", () => {
+    const NullableTestStream = co.feed(z.string().nullable());
+    const stream = NullableTestStream.create(["milk", null], { owner: me });
+
+    expect(stream.perAccount[me.id]?.value).toEqual(null);
+    expect(stream.perSession[me.sessionID]?.value).toEqual(null);
+  });
+
   test("Construction with an Account", () => {
     const stream = TestStream.create(["milk"], me);
 

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

@@ -52,6 +52,16 @@ describe("Simple CoList operations", async () => {
     expect(list[2]).toBe("c");
   });
 
+  test("list with nullable content", () => {
+    const List = co.list(z.string().nullable());
+    const list = List.create(["a", "b", "c", null]);
+    expect(list.length).toBe(4);
+    expect(list[0]).toBe("a");
+    expect(list[1]).toBe("b");
+    expect(list[2]).toBe("c");
+    expect(list[3]).toBeNull();
+  });
+
   test("Construction with an Account", () => {
     const list = TestList.create(["milk"], me);
 

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());
 

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 { Loaded } from "../internal.js";
+import { CoMap, Loaded } from "../internal.js";
 
 describe("CoMap", async () => {
   describe("init", () => {
@@ -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

@@ -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(): co.Optional<typeof Person> {
+        get friend() {
           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", () => {

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

@@ -60,6 +60,44 @@ describe("co.map and Zod schema compatibility", () => {
       expect(map.createdAt).toEqual(undefined);
     });
 
+    it("should not handle nullable date fields", () => {
+      const schema = co.map({
+        updatedAt: z.date().nullable(),
+      });
+      expect(() => schema.create({ updatedAt: null })).toThrow(
+        "Nullable z.date() is not supported",
+      );
+    });
+
+    it("should handle nullable fields", () => {
+      const schema = co.map({
+        updatedAt: z.string().nullable(),
+      });
+
+      const map = schema.create({
+        updatedAt: null,
+      });
+      expect(map.updatedAt).toBeNull();
+
+      map.updatedAt = "Test";
+      expect(map.updatedAt).toEqual("Test");
+    });
+
+    it("should handle nullish fields", () => {
+      const schema = co.map({
+        updatedAt: z.string().nullish(),
+      });
+
+      const map = schema.create({});
+      expect(map.updatedAt).toBeUndefined();
+
+      map.updatedAt = null;
+      expect(map.updatedAt).toBeNull();
+
+      map.updatedAt = "Test";
+      expect(map.updatedAt).toEqual("Test");
+    });
+
     it("should handle literal fields", async () => {
       const schema = co.map({
         status: z.literal("active"),