Merge pull request #15 from glideapps/required-in-raw-shape

Respect `required` in `jsonSchemaObjectToZodRawShape`

Author: schani

src/index.test.ts

@@ -1022,10 +1022,14 @@ describe("jsonSchemaObjectToZodRawShape", () => {
         expect(rawShape).toHaveProperty("age");
         expect(rawShape).toHaveProperty("isActive");
 
-        // Verify types are correct
+        // 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);
-        expect(rawShape.isActive instanceof z.ZodBoolean).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
+        expect((rawShape.isActive as z.ZodOptional<any>)._def.innerType instanceof z.ZodBoolean).toBe(true);
     });
 
     it("should handle empty properties", () => {
@@ -1072,7 +1076,10 @@ describe("jsonSchemaObjectToZodRawShape", () => {
         const rawShape = jsonSchemaObjectToZodRawShape(jsonSchema);
 
         expect(rawShape).toHaveProperty("user");
-        expect(rawShape.user instanceof z.ZodObject).toBe(true);
+        // Since there's no required array at the top level, user field is 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);
@@ -1090,6 +1097,11 @@ describe("jsonSchemaObjectToZodRawShape", () => {
                 user: { email: "[email protected]" },
             }),
         ).toThrow();
+        
+        // Since user is optional at the top level, empty object should pass
+        expect(() =>
+            schema.parse({}),
+        ).not.toThrow();
     });
 
     it("should be usable to build custom schemas", () => {
@@ -1136,4 +1148,73 @@ describe("jsonSchemaObjectToZodRawShape", () => {
         // Refinement with correct age, using same format as above test to confirm error was throw for correct reason
         expect(() => customSchema.parse({ age: 19 })).not.toThrow();
     });
+
+    it("should respect the required field when converting object properties", () => {
+        const jsonSchema = {
+            type: "object",
+            properties: {
+                requiredField: { type: "string" },
+                optionalField: { type: "number" },
+                anotherRequired: { type: "boolean" },
+            },
+            required: ["requiredField", "anotherRequired"],
+        };
+
+        const rawShape = jsonSchemaObjectToZodRawShape(jsonSchema);
+
+        // Create a schema to test the shape
+        const schema = z.object(rawShape);
+
+        // Required fields should be required
+        expect(() =>
+            schema.parse({
+                optionalField: 42,
+            }),
+        ).toThrow(); // Missing required fields
+
+        // Optional field should be optional
+        expect(() =>
+            schema.parse({
+                requiredField: "test",
+                anotherRequired: true,
+            }),
+        ).not.toThrow(); // Optional field missing is OK
+
+        // All fields present should work
+        expect(() =>
+            schema.parse({
+                requiredField: "test",
+                optionalField: 42,
+                anotherRequired: true,
+            }),
+        ).not.toThrow();
+    });
+
+    it("should make all fields optional when required array is not present", () => {
+        const jsonSchema = {
+            type: "object",
+            properties: {
+                field1: { type: "string" },
+                field2: { type: "number" },
+                field3: { type: "boolean" },
+            },
+            // 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({ field1: "test" })).not.toThrow();
+        expect(() => schema.parse({ field2: 42 })).not.toThrow();
+        expect(() => schema.parse({ field3: true })).not.toThrow();
+        expect(() =>
+            schema.parse({
+                field1: "test",
+                field2: 42,
+                field3: true,
+            }),
+        ).not.toThrow();
+    });
 });

src/index.ts

@@ -9,31 +9,39 @@ export { convertJsonSchemaToZod };
 export { createUniqueItemsValidator, isValidWithSchema } from "./core/utils";
 
 // Helper type to infer Zod types from JSON Schema properties
-type InferZodTypeFromJsonSchema<T> = 
-    T extends { type: "string" } ? z.ZodString :
-    T extends { type: "number" } ? z.ZodNumber :
-    T extends { type: "integer" } ? z.ZodNumber :
-    T extends { type: "boolean" } ? z.ZodBoolean :
-    T extends { type: "null" } ? z.ZodNull :
-    T extends { type: "array" } ? z.ZodArray<z.ZodTypeAny> :
-    T extends { type: "object" } ? z.ZodObject<any> :
-    T extends { const: any } ? z.ZodLiteral<T["const"]> :
-    T extends { enum: readonly any[] } ? z.ZodEnum<any> :
-    z.ZodTypeAny;
+type InferZodTypeFromJsonSchema<T> = T extends { type: "string" }
+    ? z.ZodString
+    : T extends { type: "number" }
+      ? z.ZodNumber
+      : T extends { type: "integer" }
+        ? z.ZodNumber
+        : T extends { type: "boolean" }
+          ? z.ZodBoolean
+          : T extends { type: "null" }
+            ? z.ZodNull
+            : T extends { type: "array" }
+              ? z.ZodArray<z.ZodTypeAny>
+              : T extends { type: "object" }
+                ? z.ZodObject<any>
+                : T extends { const: any }
+                  ? z.ZodLiteral<T["const"]>
+                  : T extends { enum: readonly any[] }
+                    ? z.ZodEnum<any>
+                    : z.ZodTypeAny;
 
 // Helper type to map JSON Schema properties to Zod raw shape
 type InferZodRawShape<T extends Record<string, any>> = {
-    [K in keyof T]: InferZodTypeFromJsonSchema<T[K]>
+    [K in keyof T]: InferZodTypeFromJsonSchema<T[K]>;
 };
 
 /**
  * Converts a JSON Schema object to a Zod raw shape with proper typing
  * @param schema The JSON Schema object to convert
  * @returns A Zod raw shape for use with z.object() with inferred types
  */
-export function jsonSchemaObjectToZodRawShape<
-    T extends JSONSchema.Schema & { properties: Record<string, any> }
->(schema: T): InferZodRawShape<T["properties"]>;
+export function jsonSchemaObjectToZodRawShape<T extends JSONSchema.Schema & { properties: Record<string, any> }>(
+    schema: T,
+): InferZodRawShape<T["properties"]>;
 
 /**
  * Converts a JSON Schema object to a Zod raw shape
@@ -43,11 +51,29 @@ export function jsonSchemaObjectToZodRawShape<
 export function jsonSchemaObjectToZodRawShape(schema: JSONSchema.Schema): Record<string, z.ZodTypeAny>;
 
 export function jsonSchemaObjectToZodRawShape(schema: JSONSchema.Schema): Record<string, z.ZodTypeAny> {
-    const raw: Record<string, z.ZodTypeAny> = {};
-    
+    const raw: Record<string, z.ZodType> = {};
+
+    // Get the required fields set for efficient lookup
+    const requiredArray = Array.isArray(schema.required) ? schema.required : [];
+    const requiredFields = new Set<string>(requiredArray);
+
     for (const [key, value] of Object.entries(schema.properties ?? {})) {
         if (value === undefined) continue;
-        raw[key] = convertJsonSchemaToZod(value);
+
+        let zodType = convertJsonSchemaToZod(value);
+
+        // 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)) {
+                zodType = zodType.optional();
+            }
+        } else {
+            // No required array means all fields are optional
+            zodType = zodType.optional();
+        }
+
+        raw[key] = zodType;
     }
     return raw;
-}
+}