Only accept the default if it satisfied the schema, and document

Author: schani

README.md

@@ -233,6 +233,7 @@ This library provides comprehensive support for JSON Schema Draft 2020-12 featur
 ### Additional Features
 - `title` - Schema titles (carried over to Zod schemas)
 - `description` - Schema descriptions (carried over to Zod schemas)
+- `default` - Default value annotation, but ignored if it doesn't conform to the schema
 - Boolean schemas (`true` = allow anything, `false` = allow nothing)
 - Implicit type detection from constraints
 - Comprehensive error messages

src/core/converter.ts

@@ -6,11 +6,27 @@ import { PrimitiveHandler, RefinementHandler, TypeSchemas } from "./types";
 import { TypeHandler } from "../handlers/primitive/type";
 import { ConstHandler } from "../handlers/primitive/const";
 import { EnumHandler } from "../handlers/primitive/enum";
-import { ImplicitStringHandler, MinLengthHandler, MaxLengthHandler, PatternHandler } from "../handlers/primitive/string";
-import { MinimumHandler, MaximumHandler, ExclusiveMinimumHandler, ExclusiveMaximumHandler, MultipleOfHandler } from "../handlers/primitive/number";
+import {
+    ImplicitStringHandler,
+    MinLengthHandler,
+    MaxLengthHandler,
+    PatternHandler,
+} from "../handlers/primitive/string";
+import {
+    MinimumHandler,
+    MaximumHandler,
+    ExclusiveMinimumHandler,
+    ExclusiveMaximumHandler,
+    MultipleOfHandler,
+} from "../handlers/primitive/number";
 import { ImplicitArrayHandler, MinItemsHandler, MaxItemsHandler, ItemsHandler } from "../handlers/primitive/array";
 import { TupleHandler } from "../handlers/primitive/tuple";
-import { PropertiesHandler, ImplicitObjectHandler, MaxPropertiesHandler, MinPropertiesHandler } from "../handlers/primitive/object";
+import {
+    PropertiesHandler,
+    ImplicitObjectHandler,
+    MaxPropertiesHandler,
+    MinPropertiesHandler,
+} from "../handlers/primitive/object";
 
 // Import refinement handlers
 import { NotHandler } from "../handlers/refinement/not";
@@ -33,30 +49,30 @@ const primitiveHandlers: PrimitiveHandler[] = [
     new ConstHandler(),
     new EnumHandler(),
     new TypeHandler(),
-    
+
     // Implicit type detection - must run before other constraints
     new ImplicitStringHandler(),
     new ImplicitArrayHandler(),
     new ImplicitObjectHandler(),
-    
+
     // String constraints
     new MinLengthHandler(),
     new MaxLengthHandler(),
     new PatternHandler(),
-    
+
     // Number constraints
     new MinimumHandler(),
     new MaximumHandler(),
     new ExclusiveMinimumHandler(),
     new ExclusiveMaximumHandler(),
     new MultipleOfHandler(),
-    
+
     // Array constraints - TupleHandler must run before ItemsHandler
     new TupleHandler(),
     new MinItemsHandler(),
     new MaxItemsHandler(),
     new ItemsHandler(),
-    
+
     // Object constraints
     new MaxPropertiesHandler(),
     new MinPropertiesHandler(),
@@ -68,24 +84,24 @@ const refinementHandlers: RefinementHandler[] = [
     new ProtoRequiredHandler(),
     new EnumComplexHandler(),
     new ConstComplexHandler(),
-    new DefaultHandler(),
-    
+
     // Logical combinations
     new AllOfHandler(),
     new AnyOfHandler(),
     new OneOfHandler(),
-    
+
     // Type-specific refinements
     new PrefixItemsHandler(),
     new ObjectPropertiesHandler(),
-    
+
     // Array refinements
     new ContainsHandler(),
-    
+
     // Other refinements
     new NotHandler(),
     new UniqueItemsHandler(),
-    
+    new DefaultHandler(),
+
     // Metadata last
     new MetadataHandler(),
 ];
@@ -101,14 +117,14 @@ export function convertJsonSchemaToZod(schema: JSONSchema.BaseSchema | boolean):
 
     // Phase 1: Initialize type schemas and apply primitive handlers
     const types: TypeSchemas = {};
-    
+
     for (const handler of primitiveHandlers) {
         handler.apply(types, schema);
     }
-    
+
     // Build array of allowed type schemas
     const allowedSchemas: z.ZodTypeAny[] = [];
-    
+
     if (types.string !== false) {
         allowedSchemas.push(types.string || z.string());
     }
@@ -134,12 +150,12 @@ export function convertJsonSchemaToZod(schema: JSONSchema.BaseSchema | boolean):
         } else {
             // Use custom validator that rejects arrays for default object schema
             const objectSchema = z.custom<object>((val) => {
-                return typeof val === 'object' && val !== null && !Array.isArray(val);
+                return typeof val === "object" && val !== null && !Array.isArray(val);
             }, "Must be an object, not an array");
             allowedSchemas.push(objectSchema);
         }
     }
-    
+
     // Create base schema
     let zodSchema: z.ZodTypeAny;
     if (allowedSchemas.length === 0) {
@@ -148,22 +164,22 @@ export function convertJsonSchemaToZod(schema: JSONSchema.BaseSchema | boolean):
         zodSchema = allowedSchemas[0];
     } else {
         // Check if this is an unconstrained schema (all default types enabled)
-        const hasConstraints = Object.keys(schema).some(key => 
-            key !== '$schema' && key !== 'title' && key !== 'description'
+        const hasConstraints = Object.keys(schema).some(
+            (key) => key !== "$schema" && key !== "title" && key !== "description",
         );
-        
+
         if (!hasConstraints) {
             // Empty schema with no constraints should be z.any()
             zodSchema = z.any();
         } else {
             zodSchema = z.union(allowedSchemas as [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]);
         }
     }
-    
+
     // Phase 2: Apply refinement handlers
     for (const handler of refinementHandlers) {
         zodSchema = handler.apply(zodSchema, schema);
     }
-    
+
     return zodSchema;
-}
+}

src/handlers/refinement/default.ts

@@ -1,12 +1,17 @@
 import { z } from "zod/v4";
 import type { JSONSchema } from "zod/v4/core";
 import { RefinementHandler } from "../../core/types";
-import { deepEqual } from "../../core/utils";
 
 export class DefaultHandler implements RefinementHandler {
     apply(zodSchema: z.ZodTypeAny, schema: JSONSchema.BaseSchema): z.ZodTypeAny {
-        if (!schema.default) return zodSchema;
+        const { default: v } = schema;
 
-        return zodSchema.default(schema.default);
+        if (v === undefined) return zodSchema;
+        if (!zodSchema.safeParse(v).success) {
+            // should we error-log here?
+            return zodSchema;
+        }
+
+        return zodSchema.default(v);
     }
-}
+}

src/index.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { convertJsonSchemaToZod, jsonSchemaObjectToZodRawShape } from "./index";
 import { z } from "zod/v4";
-import {JSONSchema} from "zod/v4/core";
+import { JSONSchema } from "zod/v4/core";
 
 describe("convertJsonSchemaToZod", () => {
     it("should correctly convert a schema with additionalProperties: {}", () => {
@@ -93,7 +93,11 @@ describe("convertJsonSchemaToZod", () => {
 
             const resultSchema = z.toJSONSchema(zodSchema);
             // Zod v4 converts unions to anyOf instead of enum
-            expect(resultSchema.anyOf).toEqual([{ type: "number", const: 1 }, { type: "number", const: 2 }, { type: "number", const: 3 }]);
+            expect(resultSchema.anyOf).toEqual([
+                { type: "number", const: 1 },
+                { type: "number", const: 2 },
+                { type: "number", const: 3 },
+            ]);
         });
 
         it("should correctly convert a schema with boolean enum (no type)", () => {
@@ -111,7 +115,10 @@ describe("convertJsonSchemaToZod", () => {
 
             const resultSchema = z.toJSONSchema(zodSchema);
             // Zod v4 converts unions to anyOf instead of enum
-            expect(resultSchema.anyOf).toEqual([{ type: "boolean", const: true }, { type: "boolean", const: false }]);
+            expect(resultSchema.anyOf).toEqual([
+                { type: "boolean", const: true },
+                { type: "boolean", const: false },
+            ]);
         });
 
         it("should correctly convert a schema with mixed enum (no type)", () => {
@@ -132,7 +139,12 @@ describe("convertJsonSchemaToZod", () => {
 
             const resultSchema = z.toJSONSchema(zodSchema);
             // Zod v4 converts unions to anyOf instead of enum
-            expect(resultSchema.anyOf).toEqual([{ type: "string", const: "red" }, { type: "number", const: 1 }, { type: "boolean", const: true }, { type: "null" }]);
+            expect(resultSchema.anyOf).toEqual([
+                { type: "string", const: "red" },
+                { type: "number", const: 1 },
+                { type: "boolean", const: true },
+                { type: "null" },
+            ]);
         });
 
         it("should correctly convert a schema with single item mixed enum (no type)", () => {
@@ -570,12 +582,12 @@ describe("convertJsonSchemaToZod", () => {
 
             // Test that the validation works correctly
             expect(zodSchema.safeParse("hello").success).toBe(true); // 5 chars, within range
-            expect(zodSchema.safeParse("hi").success).toBe(false);   // 2 chars, too short
+            expect(zodSchema.safeParse("hi").success).toBe(false); // 2 chars, too short
             expect(zodSchema.safeParse("this is too long").success).toBe(false); // too long
 
             // Test Unicode support
             expect(zodSchema.safeParse("💩💩💩").success).toBe(true); // 3 graphemes
-            expect(zodSchema.safeParse("💩").success).toBe(false);    // 1 grapheme, too short
+            expect(zodSchema.safeParse("💩").success).toBe(false); // 1 grapheme, too short
 
             // Note: length constraints implemented with .refine() don't round-trip
             // back to JSON Schema, so we only test the validation behavior
@@ -1025,7 +1037,7 @@ describe("jsonSchemaObjectToZodRawShape", () => {
         // Verify types are correct - required fields are direct types
         expect(rawShape.name instanceof z.ZodString).toBe(true);
         expect(rawShape.age instanceof z.ZodNumber).toBe(true);
-        
+
         // isActive is not in required array, so it should be optional
         expect(rawShape.isActive instanceof z.ZodOptional).toBe(true);
         // Check the inner type of the optional
@@ -1097,16 +1109,14 @@ describe("jsonSchemaObjectToZodRawShape", () => {
                 user: { email: "[email protected]" },
             }),
         ).toThrow();
-        
+
         // Since user is optional at the top level, empty object should pass
-        expect(() =>
-            schema.parse({}),
-        ).not.toThrow();
+        expect(() => schema.parse({})).not.toThrow();
     });
 
     it("should be usable to build custom schemas", () => {
         const jsonSchema: JSONSchema.BaseSchema = {
-          type: "object",
+            type: "object",
             properties: {
                 name: { type: "string" },
                 age: { type: "integer" },
@@ -1235,7 +1245,8 @@ describe("jsonSchemaObjectToZodRawShape", () => {
                         isActive: { type: "boolean" },
                     },
                     required: ["name", "age", "isActive"],
-                }
+                },
+                field6: { type: "string", default: 42 },
             },
             // No required field - all properties should be optional
         };
@@ -1251,6 +1262,7 @@ describe("jsonSchemaObjectToZodRawShape", () => {
             field3: true,
             field4: "test2",
             field5: { name: "test", age: 10, isActive: true },
-        })
+            // `field6` doesn't get the default, because it's not the correct type
+        });
     });
 });