Merge pull request #21 from hampusborgos/feature/default-values

schani · web-flow · commit b9faeaeb8ecd · 2025-10-27T07:08:59.000-04:00
Basic support for defaults in Schema
diff --git a/README.md b/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
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "zod-from-json-schema",
-    "version": "0.5.0",
+    "version": "0.5.1",
     "description": "Creates Zod types from JSON Schema at runtime",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
diff --git a/src/core/converter.ts b/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";
@@ -25,37 +41,38 @@ import { ConstComplexHandler } from "../handlers/refinement/constComplex";
 import { MetadataHandler } from "../handlers/refinement/metadata";
 import { ProtoRequiredHandler } from "../handlers/refinement/protoRequired";
 import { ContainsHandler } from "../handlers/refinement/contains";
+import { DefaultHandler } from "../handlers/refinement/default";
 
 // Initialize handlers
 const primitiveHandlers: PrimitiveHandler[] = [
     // Type constraints - should run first
     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(),
@@ -67,23 +84,24 @@ const refinementHandlers: RefinementHandler[] = [
     new ProtoRequiredHandler(),
     new EnumComplexHandler(),
     new ConstComplexHandler(),
-    
+
     // 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(),
 ];
@@ -99,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());
     }
@@ -132,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) {
@@ -146,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;
-}
+}
diff --git a/src/handlers/refinement/default.ts b/src/handlers/refinement/default.ts
@@ -0,0 +1,17 @@
+import { z } from "zod/v4";
+import type { JSONSchema } from "zod/v4/core";
+import { RefinementHandler } from "../../core/types";
+
+export class DefaultHandler implements RefinementHandler {
+    apply(zodSchema: z.ZodTypeAny, schema: JSONSchema.BaseSchema): z.ZodTypeAny {
+        const { default: v } = schema;
+
+        if (v === undefined) return zodSchema;
+        if (!zodSchema.safeParse(v).success) {
+            // should we error-log here?
+            return zodSchema;
+        }
+
+        return zodSchema.default(v);
+    }
+}
diff --git a/src/index.test.ts b/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: "john@example.com" },
             }),
         ).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" },
@@ -1217,4 +1227,42 @@ describe("jsonSchemaObjectToZodRawShape", () => {
             }),
         ).not.toThrow();
     });
+
+    it("schema with defaults should parse empty objects", () => {
+        const jsonSchema = {
+            type: "object",
+            properties: {
+                field1: { type: "string", default: "test" },
+                field2: { type: "number", default: 42 },
+                field3: { type: "boolean", default: true },
+                field4: { type: "string", enum: ["test1", "test2"], default: "test2" },
+                field5: {
+                    type: "object",
+                    default: { name: "test", age: 10, isActive: true },
+                    properties: {
+                        name: { type: "string" },
+                        age: { type: "integer", minimum: -43, maximum: 120 },
+                        isActive: { type: "boolean" },
+                    },
+                    required: ["name", "age", "isActive"],
+                },
+                field6: { type: "string", default: 42 },
+            },
+            // No required field - all properties should be optional
+        };
+
+        const rawShape = jsonSchemaObjectToZodRawShape(jsonSchema);
+        const schema = z.object(rawShape);
+
+        // All fields should be optional
+        expect(() => schema.parse({})).not.toThrow();
+        expect(schema.parse({})).toEqual({
+            field1: "test",
+            field2: 42,
+            field3: true,
+            field4: "test2",
+            field5: { name: "test", age: 10, isActive: true },
+            // `field6` doesn't get the default, because it's not the correct type
+        });
+    });
 });

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "zod-from-json-schema",`
`3`		`- "version": "0.5.0",`
	`3`	`+ "version": "0.5.1",`
`4`	`4`	`"description": "Creates Zod types from JSON Schema at runtime",`
`5`	`5`	`"main": "dist/index.js",`
`6`	`6`	`"module": "dist/index.mjs",`