Remove defaults from JSON Schema for transforming schemas (#4557)

* Add comments

* Remove defaults from JSON Schema for transforming schemas

Author: colinhacks

packages/zod/src/v4/classic/tests/to-json-schema.test.ts

@@ -1777,7 +1777,6 @@ test("defaults/prefaults", () => {
   expect(z.toJSONSchema(c, { io: "input" })).toMatchInlineSnapshot(`
     {
       "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "default": 1234,
       "type": "string",
     }
   `);
@@ -1954,3 +1953,31 @@ test("use output type for preprocess", () => {
     }
   `);
 });
+
+// test("isTransforming", () => {
+//   const tx = z.core.isTransforming;
+//   expect(tx(z.string())).toEqual(false);
+//   expect(tx(z.string().transform((val) => val))).toEqual(true);
+//   expect(tx(z.string().pipe(z.string()))).toEqual(false);
+//   expect(
+//     tx(
+//       z
+//         .string()
+//         .transform((val) => val)
+//         .pipe(z.string())
+//     )
+//   ).toEqual(true);
+
+//   const a = z.transform((val) => val);
+//   expect(tx(z.transform((val) => val))).toEqual(true);
+//   expect(tx(a.optional())).toEqual(true);
+
+//   const b = z.string().optional();
+//   expect(tx(b)).toEqual(false);
+
+//   const c = z.string().prefault("hello");
+//   expect(tx(c)).toEqual(false);
+
+//   const d = z.string().default("hello");
+//   expect(tx(d)).toEqual(false);
+// });

packages/zod/src/v4/core/to-json-schema.ts

@@ -542,12 +542,14 @@ export class JSONSchemaGenerator {
     // metadata
     const meta = this.metadataRegistry.get(schema);
     if (meta) Object.assign(result.schema, meta);
-    if (this.io === "input" && def.type === "pipe") {
+
+    if (this.io === "input" && isTransforming(schema)) {
       // examples/defaults only apply to output type of pipe
       delete result.schema.examples;
       delete result.schema.default;
-      if (result.schema._prefault) result.schema.default = result.schema._prefault;
     }
+
+    // set prefault as default
     if (this.io === "input" && result.schema._prefault) result.schema.default ??= result.schema._prefault;
     delete result.schema._prefault;
 
@@ -604,6 +606,8 @@ export class JSONSchemaGenerator {
       return { defId, ref: defUriPrefix + defId };
     };
 
+    // stored cached version in `def` property
+    // remove all properties, set $ref
     const extractToDef = (entry: [schemas.$ZodType<unknown, unknown>, Seen]): void => {
       if (entry[1].schema.$ref) {
         return;
@@ -680,27 +684,31 @@ export class JSONSchemaGenerator {
       const seen = this.seen.get(zodSchema)!;
       const schema = seen.def ?? seen.schema;
 
-      const _schema = { ...schema };
+      const _cached = { ...schema };
+
+      // already seen
       if (seen.ref === null) {
         return;
       }
 
+      // flatten ref if defined
       const ref = seen.ref;
-      seen.ref = null;
+      seen.ref = null; // prevent recursion
       if (ref) {
         flattenRef(ref, params);
 
+        // merge referenced schema into current
         const refSchema = this.seen.get(ref)!.schema;
-
         if (refSchema.$ref && params.target === "draft-7") {
           schema.allOf = schema.allOf ?? [];
           schema.allOf.push(refSchema);
         } else {
           Object.assign(schema, refSchema);
-          Object.assign(schema, _schema); // this is to prevent overwriting any fields in the original schema
+          Object.assign(schema, _cached); // prevent overwriting any fields in the original schema
         }
       }
 
+      // execute overrides
       if (!seen.isParent)
         this.override({
           zodSchema: zodSchema as schemas.$ZodTypes,
@@ -723,6 +731,7 @@ export class JSONSchemaGenerator {
 
     Object.assign(result, root.def);
 
+    // build defs object
     const defs: JSONSchema.BaseSchema["$defs"] = params.external?.defs ?? {};
     for (const entry of this.seen.entries()) {
       const seen = entry[1];
@@ -802,3 +811,107 @@ export function toJSONSchema(
 
   return gen.emit(input, _params);
 }
+
+function isTransforming(
+  _schema: schemas.$ZodType,
+  _ctx?: {
+    seen: Set<schemas.$ZodType>;
+  }
+): boolean {
+  const ctx = _ctx ?? { seen: new Set() };
+
+  if (ctx.seen.has(_schema)) return false;
+  ctx.seen.add(_schema);
+
+  const schema = _schema as schemas.$ZodTypes;
+  const def = schema._zod.def;
+  switch (def.type) {
+    case "string":
+    case "number":
+    case "bigint":
+    case "boolean":
+    case "date":
+    case "symbol":
+    case "undefined":
+    case "null":
+    case "any":
+    case "unknown":
+    case "never":
+    case "void":
+    case "literal":
+    case "enum":
+    case "nan":
+    case "file":
+    case "template_literal":
+      return false;
+    case "array": {
+      return isTransforming(def.element, ctx);
+    }
+    case "object": {
+      for (const key in def.shape) {
+        if (isTransforming(def.shape[key], ctx)) return true;
+      }
+      return false;
+    }
+    case "union": {
+      for (const option of def.options) {
+        if (isTransforming(option, ctx)) return true;
+      }
+      return false;
+    }
+    case "intersection": {
+      return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+    }
+    case "tuple": {
+      for (const item of def.items) {
+        if (isTransforming(item, ctx)) return true;
+      }
+      if (def.rest && isTransforming(def.rest, ctx)) return true;
+      return false;
+    }
+    case "record": {
+      return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+    }
+    case "map": {
+      return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+    }
+    case "set": {
+      return isTransforming(def.valueType, ctx);
+    }
+
+    // inner types
+    case "promise":
+    case "optional":
+    case "nonoptional":
+    case "nullable":
+    case "readonly":
+      return isTransforming(def.innerType, ctx);
+    case "lazy":
+      return isTransforming(def.getter(), ctx);
+    case "default": {
+      return isTransforming(def.innerType, ctx);
+    }
+    case "prefault": {
+      return isTransforming(def.innerType, ctx);
+    }
+    case "custom": {
+      return false;
+    }
+    case "transform": {
+      return true;
+    }
+    case "pipe": {
+      return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+    }
+    case "success": {
+      return false;
+    }
+    case "catch": {
+      return false;
+    }
+
+    default:
+      def satisfies never;
+  }
+  throw new Error(`Unknown schema type: ${(def as any).type}`);
+}

play.ts

@@ -1,3 +1,9 @@
-import { z } from "zod/v3";
+import { z } from "zod/v4";
 
 z;
+const a = z
+  .string()
+  .transform((val) => val.length)
+  .default(5);
+
+console.dir(z.toJSONSchema(a, { io: "input" }), { depth: null });