Fix jsonSchemaObjectToZodRawShape to respect required fields

Fixes #11: jsonSchemaObjectToZodRawShape now correctly handles the required
field from JSON Schema, making only non-required properties optional.

- Required fields remain as their base Zod types (ZodString, ZodNumber, etc.)
- Non-required fields are wrapped with .optional()
- When no required array is present, all fields are optional by default
- Updated tests to reflect correct behavior

Author: chenzewang

src/index.test.ts

@@ -714,10 +714,11 @@ describe("jsonSchemaObjectToZodRawShape", () => {
     expect(rawShape).toHaveProperty("age");
     expect(rawShape).toHaveProperty("isActive");
 
-    // Verify types are correct
+    // Verify types are correct - required fields should be their base types
     expect(rawShape.name instanceof z.ZodString).toBe(true);
     expect(rawShape.age instanceof z.ZodNumber).toBe(true);
-    expect(rawShape.isActive instanceof z.ZodBoolean).toBe(true);
+    // Non-required fields should be optional
+    expect(rawShape.isActive instanceof z.ZodOptional).toBe(true);
   });
 
   it("should handle empty properties", () => {
@@ -759,7 +760,10 @@ describe("jsonSchemaObjectToZodRawShape", () => {
     const rawShape = jsonSchemaObjectToZodRawShape(jsonSchema);
 
     expect(rawShape).toHaveProperty("user");
-    expect(rawShape.user instanceof z.ZodObject).toBe(true);
+    // Since user is not in the required array at the top level, it should be optional
+    expect(rawShape.user instanceof z.ZodOptional).toBe(true);
+    // The inner type should be a ZodObject
+    expect((rawShape.user as z.ZodOptional<any>)._def.innerType instanceof z.ZodObject).toBe(true);
 
     // Create a schema with the raw shape to test validation
     const schema = z.object(rawShape);

src/index.ts

@@ -319,8 +319,28 @@ export function convertJsonSchemaToZod(schema: JSONSchema): z.ZodTypeAny {
  */
 export function jsonSchemaObjectToZodRawShape(schema: JSONSchema): z.ZodRawShape {
     let raw: z.ZodRawShape = {};
-    for (const [key, value] of Object.entries(schema.properties ?? {})) {
-        raw[key] = convertJsonSchemaToZod(value);
+
+    // Get the required fields set for efficient lookup
+    const requiredArray = Array.isArray(schema.required) ? schema.required : [];
+    const requiredFields = new Set<string>(requiredArray);
+
+    // Process each property
+    for (const [key, propSchema] of Object.entries(schema.properties ?? {})) {
+        let zodSchema = convertJsonSchemaToZod(propSchema);
+
+        // If there's a required array and the field is not in it, make it optional
+        // If there's no required array, all fields are optional by default in JSON Schema
+        if (requiredArray.length > 0) {
+            if (!requiredFields.has(key)) {
+                zodSchema = zodSchema.optional();
+            }
+        } else {
+            // No required array means all fields are optional
+            zodSchema = zodSchema.optional();
+        }
+
+        raw[key] = zodSchema;
     }
+
     return raw;
 }