jazz-tools 0.14.9 → 0.14.14

package/src/implementation/zodSchema/runtimeConverters/zodFieldToCoFieldDef.ts

@@ -5,7 +5,13 @@ import {
   isUnionOfPrimitivesDeeply,
   schemaUnionDiscriminatorFor,
 } from "../unionUtils.js";
-import { ZodLazy, ZodReadonly, z } from "../zodReExport.js";
+import {
+  ZodCatch,
+  ZodDefault,
+  ZodLazy,
+  ZodReadonly,
+  z,
+} from "../zodReExport.js";
 import { ZodPrimitiveSchema } from "../zodSchema.js";
 import { zodSchemaToCoSchemaOrKeepPrimitive } from "./zodSchemaToCoSchema.js";
 
@@ -23,6 +29,8 @@ type FieldSchema =
   | z.core.$ZodLiteral<any>
   | z.core.$ZodCatch<z.core.$ZodType>
   | z.core.$ZodEnum<any>
+  | z.core.$ZodDefault<z.core.$ZodType>
+  | z.core.$ZodCatch<z.core.$ZodType>
   | (z.core.$ZodCustom<any, any> & { builtin: any });
 
 export function zodFieldToCoFieldDef(schema: FieldSchema) {
@@ -62,6 +70,18 @@ export function zodFieldToCoFieldDef(schema: FieldSchema) {
         return zodFieldToCoFieldDef(
           (schema as unknown as ZodLazy).unwrap() as FieldSchema,
         );
+      } else if (
+        schema._zod.def.type === "default" ||
+        schema._zod.def.type === "catch"
+      ) {
+        console.warn(
+          "z.default()/z.catch() are not supported in collaborative schemas. They will be ignored.",
+        );
+
+        return zodFieldToCoFieldDef(
+          (schema as unknown as ZodDefault | ZodCatch).def
+            .innerType as FieldSchema,
+        );
       } else if (schema._zod.def.type === "literal") {
         if (
           schema._zod.def.values.some(

package/src/implementation/zodSchema/schemaTypes/CoListSchema.ts

@@ -46,6 +46,7 @@ export type CoListSchema<T extends z.core.$ZodType> = z.core.$ZodArray<T> & {
     ) => void,
   ): () => void;
 
+  /** @deprecated Define your helper methods separately, in standalone functions. */
   withHelpers<S extends z.core.$ZodType, T extends object>(
     this: S,
     helpers: (Self: S) => T,

package/src/implementation/zodSchema/schemaTypes/CoMapSchema.ts

@@ -92,6 +92,7 @@ export type CoMapSchema<
       schema: T,
     ): CoMapSchema<Shape, z.core.$catchall<T>>;
 
+    /** @deprecated Define your helper methods separately, in standalone functions. */
     withHelpers<S extends z.core.$ZodType, T extends object>(
       this: S,
       helpers: (Self: S) => T,

package/src/implementation/zodSchema/schemaTypes/CoRecordSchema.ts

@@ -78,6 +78,7 @@ export type CoRecordSchema<
     as?: Account | Group | AnonymousJazzAgent,
   ): ID<CoRecordInstanceCoValuesNullable<K, V>>;
 
+  /** @deprecated Define your helper methods separately, in standalone functions. */
   withHelpers<S extends z.core.$ZodType, T extends object>(
     this: S,
     helpers: (Self: S) => T,

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

@@ -99,7 +99,15 @@ export type InstanceOrPrimitiveOfSchema<
                                                   infer Inner
                                                 >
                                               ? InstanceOrPrimitiveOfSchema<Inner>
-                                              : never
+                                              : S extends z.core.$ZodDefault<
+                                                    infer Default
+                                                  >
+                                                ? InstanceOrPrimitiveOfSchema<Default>
+                                                : S extends z.core.$ZodCatch<
+                                                      infer Catch
+                                                    >
+                                                  ? InstanceOrPrimitiveOfSchema<Catch>
+                                                  : never
   : S extends CoValueClass
     ? InstanceType<S>
     : never;

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

@@ -112,7 +112,15 @@ export type InstanceOrPrimitiveOfSchemaCoValuesNullable<
                                                   infer Inner
                                                 >
                                               ? InstanceOrPrimitiveOfSchema<Inner>
-                                              : never
+                                              : S extends z.core.$ZodDefault<
+                                                    infer Default
+                                                  >
+                                                ? InstanceOrPrimitiveOfSchema<Default>
+                                                : S extends z.core.$ZodCatch<
+                                                      infer Catch
+                                                    >
+                                                  ? InstanceOrPrimitiveOfSchema<Catch>
+                                                  : never
   : S extends CoValueClass
     ? InstanceType<S> | null
     : never;

package/src/implementation/zodSchema/zodCo.ts

@@ -45,6 +45,7 @@ export const coMapDefiner = <Shape extends z.core.$ZodLooseShape>(
     subscribe: CoMapSchema<Shape>["subscribe"];
     findUnique: CoMapSchema<Shape>["findUnique"];
     catchall: CoMapSchema<Shape>["catchall"];
+    /** @deprecated Define your helper methods separately, in standalone functions. */
     withHelpers: CoMapSchema<Shape>["withHelpers"];
   };
 
@@ -130,6 +131,7 @@ export const coAccountDefiner = <
     getMe: AccountSchema<Shape>["getMe"];
     load: AccountSchema<Shape>["load"];
     subscribe: AccountSchema<Shape>["subscribe"];
+    /** @deprecated Define your helper methods separately, in standalone functions. */
     withHelpers: AccountSchema<Shape>["withHelpers"];
     withMigration: AccountSchema<Shape>["withMigration"];
   };
@@ -210,6 +212,7 @@ export const coListDefiner = <T extends z.core.$ZodType>(
     create: CoListSchema<T>["create"];
     load: CoListSchema<T>["load"];
     subscribe: CoListSchema<T>["subscribe"];
+    /** @deprecated Define your helper methods separately, in standalone functions. */
     withHelpers: CoListSchema<T>["withHelpers"];
   };
 

package/src/implementation/zodSchema/zodReExport.ts

@@ -36,6 +36,8 @@ export {
   type ZodOptional,
   type ZodReadonly,
   type ZodLazy,
+  type ZodDefault,
+  type ZodCatch,
   type output as infer,
   z,
 } from "zod/v4";

package/src/subscribe/SubscriptionScope.ts

@@ -222,6 +222,12 @@ export class SubscriptionScope<D extends CoValue> {
     return true;
   }
 
+  getCurrentValue() {
+    if (!this.shouldSendUpdates()) return;
+    if (this.errorFromChildren) return this.errorFromChildren;
+    return this.value;
+  }
+
   triggerUpdate() {
     if (!this.shouldSendUpdates()) return;
     if (!this.dirty) return;

package/src/tests/zod.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { z } from "../exports.js";
 import { co } from "../internal.js";
 import { createJazzTestAccount } from "../testing.js";
@@ -380,23 +380,41 @@ describe("co.map and Zod schema compatibility", () => {
       expect(map.longString).toBe("this is a long string");
     });
 
-    // it("should fire error on default values", async () => {
-    //   const schema = co.map({
-    //     fish: z.string().default("tuna"),
-    //   });
-    //   const account = await createJazzTestAccount();
-    //   const map = schema.create({}, account);
-    //   expect(map.fish).toBe("tuna");
-    // });
+    it("should log a warning on default values", async () => {
+      const consoleSpy = vi.spyOn(console, "warn");
 
-    // it("should fire error catch values", async () => {
-    //   const schema = co.map({
-    //     number: z.number().catch(42),
-    //   });
-    //   const account = await createJazzTestAccount();
-    //   const map = schema.create({ number: 42 }, account);
-    //   expect(map.number).toBe(42);
-    // });
+      const schema = co.map({
+        fish: z.string().default("tuna"),
+      });
+      const account = await createJazzTestAccount();
+      const map = schema.create(
+        {
+          fish: "salmon",
+        },
+        account,
+      );
+      expect(map.fish).toBe("salmon");
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "z.default()/z.catch() are not supported in collaborative schemas. They will be ignored.",
+      );
+      consoleSpy.mockRestore();
+    });
+
+    it("should log a warning on catch values", async () => {
+      const consoleSpy = vi.spyOn(console, "warn");
+      const schema = co.map({
+        number: z.number().catch(42),
+      });
+      const account = await createJazzTestAccount();
+      const map = schema.create({ number: 18 }, account);
+      expect(map.number).toBe(18);
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "z.default()/z.catch() are not supported in collaborative schemas. They will be ignored.",
+      );
+      consoleSpy.mockRestore();
+    });
 
     it("should handle branded types", async () => {
       const schema = co.map({