@signe/schema-to-zod 1.4.0

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@signe/schema-to-zod",
+  "version": "1.4.0",
+  "description": "",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsup src/index.ts",
+    "dev": "tsup src/index.ts --watch"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": "./*"
+  },
+  "keywords": [],
+  "author": "Samuel Ronce",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "dependencies": {
+    "@types/json-schema": "^7.0.15"
+  }
+}

package/readme.md

@@ -0,0 +1,150 @@
+# Schema to Zod
+
+Convert JSON Schema to Zod validation schemas.
+
+## Installation
+
+```bash
+npm install @signe/schema-to-zod
+```
+
+## Usage
+
+```typescript
+import { jsonSchemaToZod } from '@signe/schema-to-zod';
+import { z } from 'zod';
+
+// Define your JSON Schema
+const schema = {
+  type: 'object',
+  properties: {
+    name: { type: 'string', minLength: 3 },
+    email: { type: 'string', format: 'email' },
+    age: { type: 'integer', minimum: 18 },
+    tags: { 
+      type: 'array',
+      items: { type: 'string' },
+      minItems: 1
+    }
+  },
+  required: ['name', 'email']
+};
+
+// Convert to Zod schema
+const zodSchema = z.object(jsonSchemaToZod(schema));
+
+// Use the schema for validation
+const result = zodSchema.safeParse({
+  name: 'John',
+  email: 'john@example.com',
+  age: 25,
+  tags: ['developer']
+});
+
+if (result.success) {
+  console.log('Valid data:', result.data);
+} else {
+  console.log('Validation errors:', result.error);
+}
+```
+
+## Features
+
+- Supports common JSON Schema types:
+  - string
+  - number
+  - integer
+  - boolean
+  - array
+  - object
+  - null
+
+- Handles JSON Schema formats:
+  - date
+  - date-time
+  - email
+  - hostname
+  - ipv4
+  - ipv6
+  - uri
+  - uuid
+  - color
+  - password
+  - code
+  - percent
+
+- Supports validation rules:
+  - required fields
+  - string: minLength, maxLength, pattern
+  - number: minimum, maximum
+  - array: minItems, maxItems
+  - enum values
+
+## API
+
+### `jsonSchemaToZod(schema: JSONSchema7 | JSONSchema7Definition[]): Record<string, ZodType<unknown>>`
+
+Converts a JSON Schema to a Zod schema object.
+
+Parameters:
+- `schema`: A JSON Schema object or array of schema objects
+
+Returns:
+- A record of Zod type definitions that can be used with `z.object()`
+
+## Examples
+
+### Nested Objects
+
+```typescript
+const schema = {
+  type: 'object',
+  properties: {
+    user: {
+      type: 'object',
+      properties: {
+        profile: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            age: { type: 'integer' }
+          },
+          required: ['name']
+        }
+      }
+    }
+  }
+};
+
+const zodSchema = z.object(jsonSchemaToZod(schema));
+```
+
+### Array Validation
+
+```typescript
+const schema = {
+  type: 'object',
+  properties: {
+    users: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'integer' }
+        },
+        required: ['name']
+      },
+      minItems: 1,
+      maxItems: 3
+    }
+  },
+  required: ['users']
+};
+
+const zodSchema = z.object(jsonSchemaToZod(schema));
+```
+
+## License
+
+MIT

package/src/index.ts

@@ -0,0 +1,207 @@
+import { z, ZodType, ZodTypeDef } from "zod";
+import type { JSONSchema7, JSONSchema7Definition, JSONSchema7TypeName } from "json-schema";
+
+/**
+ * Standard JSON Schema types only
+ */
+type SchemaType = Exclude<JSONSchema7TypeName, 'array' | 'object'> | 'array' | 'object';
+
+function isValidSchemaType(type: unknown): type is SchemaType {
+    if (typeof type !== 'string') return false;
+    return ['string', 'number', 'boolean', 'integer', 'array', 'object', 'null'].includes(type);
+}
+
+function isJSONSchema7(schema: JSONSchema7Definition): schema is JSONSchema7 {
+    return typeof schema !== 'boolean';
+}
+
+/**
+ * Zod schema for percentage values (0-100)
+ */
+const percent = z.number().min(0).max(100);
+
+/**
+ * Map of JSON Schema formats to their corresponding Zod schema creators
+ */
+const formatMap: Record<string, (schema: JSONSchema7) => ZodType<unknown>> = {
+    'date': () => z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+    'date-time': () => z.string().datetime(),
+    'email': () => z.string().email(),
+    'hostname': () => z.string(),
+    'ipv4': () => z.string().ip({ version: 'v4' }),
+    'ipv6': () => z.string().ip({ version: 'v6' }),
+    'uri': () => z.string().url(),
+    'uuid': () => z.string().uuid(),
+    'color': () => z.string().regex(/^#(?:[0-9a-fA-F]{3}){1,2}$/),
+    'password': () => z.string(),
+    'code': () => z.string(),
+    'percent': () => percent,
+};
+
+/**
+ * Map of JSON Schema types to their corresponding Zod schema creators
+ */
+const typeMap: Record<SchemaType, (schema: JSONSchema7) => ZodType<unknown, ZodTypeDef, unknown>> = {
+    'string': (schema) => {
+        if (schema.format && formatMap[schema.format]) {
+            return formatMap[schema.format](schema);
+        }
+        return z.string();
+    },
+    'number': (schema) => {
+        if (schema.format === 'percent') {
+            return percent;
+        }
+        return z.number();
+    },
+    'integer': () => z.number().int(),
+    'boolean': () => z.boolean(),
+    'null': () => z.null(),
+    'array': (schema: JSONSchema7) => {
+        if (!schema.items || Array.isArray(schema.items)) {
+            throw new Error('Invalid array items');
+        }
+
+        if (!isJSONSchema7(schema.items)) {
+            throw new Error('Boolean schema is not supported for array items');
+        }
+
+        if (schema.items.type === 'object') {
+            return z.array(z.object(jsonSchemaToZod(schema.items)));
+        }
+
+        const itemType = schema.items.type;
+        if (!itemType || !isValidSchemaType(itemType)) {
+            throw new Error(`Unsupported array item type: ${itemType}`);
+        }
+
+        return z.array(typeMap[itemType](schema.items));
+    },
+    'object': (schema: JSONSchema7) => {
+        if (!schema.properties) {
+            throw new Error('Invalid object schema: missing properties');
+        }
+        return z.object(jsonSchemaToZod(schema));
+    }
+};
+
+/**
+ * Applies validators to a Zod schema based on JSON Schema property constraints
+ */
+function applyValidators(
+    zodType: ZodType<unknown>,
+    schema: JSONSchema7,
+    required: boolean
+): ZodType<unknown> {
+    let zodTypeWithValidators = zodType;
+
+    // String validators
+    if (schema.type === 'string' && required) {
+        zodTypeWithValidators = (zodTypeWithValidators as z.ZodString).min(1);
+
+        if (schema.minLength !== undefined) {
+            zodTypeWithValidators = (zodTypeWithValidators as z.ZodString).min(schema.minLength);
+        }
+
+        if (schema.maxLength !== undefined) {
+            zodTypeWithValidators = (zodTypeWithValidators as z.ZodString).max(schema.maxLength);
+        }
+    }
+
+    // Array validators
+    if (schema.type === 'array') {
+        if (schema.minItems !== undefined) {
+            zodTypeWithValidators = (zodTypeWithValidators as z.ZodArray<ZodType>).min(schema.minItems);
+        }
+        if (schema.maxItems !== undefined) {
+            zodTypeWithValidators = (zodTypeWithValidators as z.ZodArray<ZodType>).max(schema.maxItems);
+        }
+    }
+
+    // Number validators
+    if (schema.type === 'number' || schema.type === 'integer') {
+        if (schema.minimum !== undefined) {
+            zodTypeWithValidators = (zodTypeWithValidators as z.ZodNumber).min(schema.minimum);
+        }
+
+        if (schema.maximum !== undefined) {
+            zodTypeWithValidators = (zodTypeWithValidators as z.ZodNumber).max(schema.maximum);
+        }
+    }
+
+    // Enum validators
+    if (schema.enum) {
+        zodTypeWithValidators = zodTypeWithValidators.refine(
+            (value): value is typeof schema.enum[number] => schema.enum!.includes(value as string),
+            {
+                message: `Must be one of: ${schema.enum.join(", ")}`,
+            }
+        );
+    }
+
+    // Pattern validators
+    if (schema.pattern) {
+        zodTypeWithValidators = (zodTypeWithValidators as z.ZodString).regex(new RegExp(schema.pattern));
+    }
+
+    return zodTypeWithValidators;
+}
+
+function getTypeFunction(schema: JSONSchema7): ZodType<unknown> {
+    if (!schema.type || !isValidSchemaType(schema.type as string)) {
+        throw new Error(`Unsupported type: ${schema.type}`);
+    }
+    return typeMap[schema.type as SchemaType](schema);
+}
+
+/**
+ * Converts a JSON Schema property to a Zod schema
+ */
+function convertPropertyToZod(
+    schema: JSONSchema7,
+    key: string,
+    parentSchema: JSONSchema7
+): ZodType<unknown> {
+    if (schema.$ref) {
+        return z.array(
+            z.object({
+                value: z.object({
+                    id: z.string()
+                })
+            })
+        );
+    }
+
+    if (schema.type === 'object') {
+        return z.object(jsonSchemaToZod(schema));
+    }
+
+    const required = Array.isArray(parentSchema.required) && parentSchema.required.includes(key);
+    const typeValidator = applyValidators(getTypeFunction(schema), schema, required);
+    return required ? typeValidator : typeValidator.optional();
+}
+
+/**
+ * Converts a JSON Schema to a Zod schema
+ */
+export function jsonSchemaToZod(
+    schema: JSONSchema7 | JSONSchema7Definition[],
+): Record<string, ZodType<unknown>> {
+    const zodSchema: Record<string, ZodType<unknown>> = {};
+
+    if (Array.isArray(schema)) {
+        // Handle array of schemas (merge all schemas)
+        for (const item of schema) {
+            if (!isJSONSchema7(item)) continue;
+            Object.assign(zodSchema, jsonSchemaToZod(item));
+        }
+    } else if (schema.type === 'object' && schema.properties) {
+        // Handle object schema
+        for (const [key, prop] of Object.entries(schema.properties)) {
+            if (!isJSONSchema7(prop)) continue;
+            zodSchema[key] = convertPropertyToZod(prop, key, schema);
+        }
+    }
+
+    return zodSchema;
+}

package/tests/validate.spec.ts

@@ -0,0 +1,302 @@
+import { afterEach, beforeEach, describe, expect, test } from 'vitest'
+import { jsonSchemaToZod } from '../src'
+import { z } from 'zod'
+
+describe('jsonSchemaToZod', () => {
+
+    test('Should convert basic types correctly', async () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                email: { type: 'string', format: 'email' },
+                age: { type: 'integer' },
+                isActive: { type: 'boolean' },
+                scores: { type: 'array', items: { type: 'number' } },
+            },
+            required: ['name', 'email']
+        }
+
+        const zodSchema = jsonSchemaToZod(schema)
+
+        expect(Object.keys(zodSchema)).toEqual(['name', 'email', 'age', 'isActive', 'scores'])
+    })
+
+    test('Should throw an error for unsupported types', async () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                unsupportedProp: { type: 'unsupported' }
+            }
+        }
+
+        expect(() => jsonSchemaToZod(schema)).toThrow('Unsupported type: unsupported')
+    })
+
+    test('Should apply validators correctly', async () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string', minLength: 3, maxLength: 50 },
+                age: { type: 'integer', minimum: 18, maximum: 100 },
+            },
+            required: ['name']
+        }
+
+        const zodSchema = z.object(jsonSchemaToZod(schema))
+
+        // Name is required
+        let result = zodSchema.safeParse({ age: 30 })
+        expect(result.success).toBeFalsy()
+
+        // Name is too short
+        result = zodSchema.safeParse({ name: 'Jo', age: 30 })
+        expect(result.success).toBeFalsy()
+
+        // Name is too long
+        result = zodSchema.safeParse({ name: 'J'.repeat(51), age: 30 })
+        expect(result.success).toBeFalsy()
+
+        // Age is too low
+        result = zodSchema.safeParse({ name: 'John', age: 17 })
+        expect(result.success).toBeFalsy()
+
+        // Age is too high
+        result = zodSchema.safeParse({ name: 'John', age: 101 })
+        expect(result.success).toBeFalsy()
+
+        // All validations pass
+        result = zodSchema.safeParse({ name: 'John', age: 30 })
+        expect(result.success).toBeTruthy()
+    })
+
+    test('Should handle string type correctly', async () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+            },
+        }
+
+        const zodSchema = z.object(jsonSchemaToZod(schema))
+
+        // Name is not a string
+        let result = zodSchema.safeParse({ name: 123 })
+        expect(result.success).toBeFalsy()
+
+        // Name is a string
+        result = zodSchema.safeParse({ name: 'John' })
+        expect(result.success).toBeTruthy()
+    })
+
+    test('Should handle special types correctly', async () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                colorCode: { type: 'string', format: 'color' },
+                secretCode: { type: 'string', format: 'code' },
+                userPassword: { type: 'string', format: 'password' },
+                percentage: { type: 'number', format: 'percent' },
+                createdAt: { type: 'string', format: 'date' },
+                description: { type: 'string' }
+            }
+        }
+
+        const zodSchema = z.object(jsonSchemaToZod(schema))
+
+        // Test color validation
+        expect(zodSchema.safeParse({ colorCode: '#123456' }).success).toBeTruthy()
+        expect(zodSchema.safeParse({ colorCode: '#abc' }).success).toBeTruthy()
+        expect(zodSchema.safeParse({ colorCode: 'invalid' }).success).toBeFalsy()
+
+        // Test percent validation
+        expect(zodSchema.safeParse({ percentage: 50 }).success).toBeTruthy()
+        expect(zodSchema.safeParse({ percentage: 101 }).success).toBeFalsy()
+        expect(zodSchema.safeParse({ percentage: -1 }).success).toBeFalsy()
+    })
+
+    test('Should handle nested objects correctly', async () => {
+        const schema = {
+            type: 'object' as const,
+            properties: {
+                user: {
+                    type: 'object' as const,
+                    properties: {
+                        profile: {
+                            type: 'object' as const,
+                            properties: {
+                                name: { type: 'string' as const },
+                                age: { type: 'integer' as const }
+                            },
+                            required: ['name']
+                        }
+                    }
+                }
+            }
+        }
+
+        const zodSchema = z.object(jsonSchemaToZod(schema))
+
+        expect(zodSchema.safeParse({
+            user: {
+                profile: {
+                    name: 'John',
+                    age: 30
+                }
+            }
+        }).success).toBeTruthy()
+
+        expect(zodSchema.safeParse({
+            user: {
+                profile: {
+                    age: 30
+                }
+            }
+        }).success).toBeFalsy()
+    })
+
+    test('Should handle array of schemas correctly', async () => {
+        const schemas = [
+            {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' }
+                    }
+                }
+            },
+            {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        age: { type: 'integer' }
+                    }
+                }
+            }
+        ]
+
+        const zodSchema = z.object(jsonSchemaToZod(schemas))
+
+        expect(zodSchema.safeParse({
+            name: 'John',
+            age: 30
+        }).success).toBeTruthy()
+    })
+
+    test('Should handle $ref correctly', async () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                categories: {
+                    $ref: '#/definitions/CategoryList'
+                }
+            }
+        }
+
+        const zodSchema = z.object(jsonSchemaToZod(schema))
+
+        expect(zodSchema.safeParse({
+            categories: [
+                { value: { id: '123' } }
+            ]
+        }).success).toBeTruthy()
+
+        expect(zodSchema.safeParse({
+            categories: [
+                { value: { wrong: '123' } }
+            ]
+        }).success).toBeFalsy()
+    })
+
+    test('Should handle pattern and enum validations', async () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                code: { 
+                    type: 'string',
+                    pattern: '^[A-Z]{3}[0-9]{3}$'
+                },
+                status: {
+                    type: 'string',
+                    enum: ['active', 'inactive', 'pending']
+                }
+            }
+        }
+
+        const zodSchema = z.object(jsonSchemaToZod(schema))
+
+        // Test pattern validation
+        expect(zodSchema.safeParse({ code: 'ABC123' }).success).toBeTruthy()
+        expect(zodSchema.safeParse({ code: 'invalid' }).success).toBeFalsy()
+
+        // Test enum validation
+        expect(zodSchema.safeParse({ status: 'active' }).success).toBeTruthy()
+        expect(zodSchema.safeParse({ status: 'invalid' }).success).toBeFalsy()
+    })
+
+    test('Should handle array items with complex validation', async () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                users: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            age: { type: 'integer' }
+                        },
+                        required: ['name']
+                    },
+                    minItems: 1,
+                    maxItems: 3
+                }
+            },
+            required: ['users']
+        }
+
+        const zodSchema = z.object(jsonSchemaToZod(schema))
+
+        // Valid case
+        let result = zodSchema.safeParse({
+            users: [
+                { name: 'John', age: 30 },
+                { name: 'Jane', age: 25 }
+            ]
+        })
+        expect(result.success).toBeTruthy()
+
+        // Too many items
+        result = zodSchema.safeParse({
+            users: [
+                { name: 'John', age: 30 },
+                { name: 'Jane', age: 25 },
+                { name: 'Bob', age: 35 },
+                { name: 'Alice', age: 28 }
+            ]
+        })
+        expect(result.success).toBeFalsy()
+
+        // Missing required field in array item
+        result = zodSchema.safeParse({
+            users: [
+                { age: 30 }
+            ]
+        })
+        expect(result.success).toBeFalsy()
+
+        // Wrong type in array item
+        result = zodSchema.safeParse({
+            users: [
+                { name: 'John', age: 'thirty' }
+            ]
+        })
+        expect(result.success).toBeFalsy()
+
+        // Empty array (violates minItems)
+        result = zodSchema.safeParse({
+            users: []
+        })
+        expect(result.success).toBeFalsy()
+    })
+})