Doc and test the other function

Author: schani

README.md

@@ -87,6 +87,53 @@ try {
 }
 ```
 
+## API Reference
+
+### `convertJsonSchemaToZod(schema)`
+
+Converts a JSON Schema object to a complete Zod schema.
+
+- **Parameters**:
+  - `schema` (Object): A JSON Schema object
+- **Returns**: 
+  - A Zod schema that validates according to the JSON Schema
+
+### `jsonSchemaObjectToZodRawShape(schema)`
+
+Extracts the object properties from a JSON Schema object into a Zod raw shape. This is useful when you want to combine the properties with other Zod object configurations.
+
+- **Parameters**:
+  - `schema` (Object): A JSON Schema object that should have a `properties` field
+- **Returns**: 
+  - A `ZodRawShape` object that can be used with `z.object()`
+
+**Example**:
+
+```typescript
+import { jsonSchemaObjectToZodRawShape } from 'zod-from-json-schema';
+import { z } from 'zod';
+
+const jsonSchema = {
+  properties: {
+    name: { type: "string" },
+    age: { type: "integer" }
+  },
+  required: ["name"]
+};
+
+// Get just the property definitions
+const rawShape = jsonSchemaObjectToZodRawShape(jsonSchema);
+
+// Add custom handling
+const customSchema = z.object({
+  ...rawShape,
+  // Add additional fields not in the JSON Schema
+  createdAt: z.date().default(() => new Date())
+}).refine(data => data.age > 18, {
+  message: "Age must be over 18 to continue"
+});
+```
+
 ## Supported JSON Schema Features
 
 This library supports the following JSON Schema features:

src/index.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from "vitest";
-import { convertJsonSchemaToZod } from "./index";
+import { convertJsonSchemaToZod, jsonSchemaObjectToZodRawShape } from "./index";
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { z } from "zod";
 
 describe("convertJsonSchemaToZod", () => {
   it("should correctly convert a schema with additionalProperties: true", () => {
@@ -185,4 +186,123 @@ describe("convertJsonSchemaToZod", () => {
       expect(resultSchema.items).toEqual({ type: "string" });
     });
   });
+});
+
+describe("jsonSchemaObjectToZodRawShape", () => {
+  it("should extract properties from a JSON schema", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        age: { type: "integer" },
+        isActive: { type: "boolean" },
+      },
+      required: ["name", "age"]
+    };
+
+    const rawShape = jsonSchemaObjectToZodRawShape(jsonSchema);
+    
+    // Properties should exist in the raw shape
+    expect(rawShape).toHaveProperty("name");
+    expect(rawShape).toHaveProperty("age");
+    expect(rawShape).toHaveProperty("isActive");
+    
+    // Verify types are correct
+    expect(rawShape.name instanceof z.ZodString).toBe(true);
+    expect(rawShape.age instanceof z.ZodNumber).toBe(true);
+    expect(rawShape.isActive instanceof z.ZodBoolean).toBe(true);
+  });
+
+  it("should handle empty properties", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {}
+    };
+
+    const rawShape = jsonSchemaObjectToZodRawShape(jsonSchema);
+    expect(Object.keys(rawShape).length).toBe(0);
+    expect(rawShape).toEqual({});
+  });
+
+  it("should handle missing properties field", () => {
+    const jsonSchema = {
+      type: "object"
+    };
+
+    const rawShape = jsonSchemaObjectToZodRawShape(jsonSchema);
+    expect(Object.keys(rawShape).length).toBe(0);
+    expect(rawShape).toEqual({});
+  });
+
+  it("should correctly convert nested object properties", () => {
+    const jsonSchema = {
+      type: "object",
+      properties: {
+        user: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            email: { type: "string" }
+          },
+          required: ["name"]
+        }
+      }
+    };
+
+    const rawShape = jsonSchemaObjectToZodRawShape(jsonSchema);
+    
+    expect(rawShape).toHaveProperty("user");
+    expect(rawShape.user instanceof z.ZodObject).toBe(true);
+    
+    // Create a schema with the raw shape to test validation
+    const schema = z.object(rawShape);
+    
+    // Valid data should pass
+    expect(() => schema.parse({
+      user: { name: "John", email: "[email protected]" }
+    })).not.toThrow();
+    
+    // Missing required field should fail
+    expect(() => schema.parse({
+      user: { email: "[email protected]" }
+    })).toThrow();
+  });
+
+  it("should be usable to build custom schemas", () => {
+    const jsonSchema = {
+      properties: {
+        name: { type: "string" },
+        age: { type: "integer" }
+      }
+    };
+
+    // Get the raw shape
+    const rawShape = jsonSchemaObjectToZodRawShape(jsonSchema);
+    
+    // Make fields optional manually and add custom fields
+    const customSchema = z.object({
+      name: rawShape.name.optional(),
+      age: rawShape.age.optional(),
+      createdAt: z.date().default(() => new Date())
+    }).refine(data => data.age === undefined || data.age > 18, {
+      message: "Age must be over 18"
+    });
+    
+    // Test validation with the custom schema - all fields work
+    const validData = customSchema.parse({ 
+      name: "John", 
+      age: 25 
+    });
+    expect(validData).toHaveProperty("name", "John");
+    expect(validData).toHaveProperty("age", 25);
+    expect(validData).toHaveProperty("createdAt");
+    expect(validData.createdAt instanceof Date).toBe(true);
+    
+    // Test with missing fields 
+    const dataWithMissingField = customSchema.parse({});
+    expect(dataWithMissingField).toHaveProperty("createdAt");
+    
+    // Test refinement with invalid age
+    expect(() => customSchema.parse({ age: 16 })).toThrow();
+  });
 });