Schema to Library

npm install -D schema-to-library

What is schema-to-library?

schema-to-library is a CLI tool that converts JSON Schema into code for validation libraries. It helps you automatically generate type-safe validation schemas and TypeScript types from your existing schema definitions.

Supported Libraries

• Zod
• Valibot
• Effect Schema
• TypeBox
• Arktype

Usage

CLI Usage

npx schema-to-zod path/to/input.{json,yaml} -o path/to/output.ts
npx schema-to-valibot path/to/input.{json,yaml} -o path/to/output.ts
npx schema-to-effect path/to/input.{json,yaml} -o path/to/output.ts
npx schema-to-typebox path/to/input.{json,yaml} -o path/to/output.ts
npx schema-to-arktype path/to/input.{json,yaml} -o path/to/output.ts

Options

| Flag | Description | | --------------- | ----------------------------- | | --export-type | Include type export in output | | --readonly | Generate readonly types | | -h, --help | Display help for command |

Example

input:

{
  "title": "User",
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "email": { "type": "string", "format": "email" },
    "age": { "type": "integer", "minimum": 0 }
  },
  "required": ["name", "email"]
}

Default output (schema only):

Zod

import * as z from 'zod'

export const User = z.object({
  name: z.string(),
  email: z.email(),
  age: z.int().min(0).optional(),
})

Valibot

import * as v from 'valibot'

export const User = v.object({
  name: v.string(),
  email: v.pipe(v.string(), v.email()),
  age: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
})

Effect Schema

import { Schema } from 'effect'

export const User = Schema.Struct({
  name: Schema.String,
  email: Schema.String,
  age: Schema.optional(Schema.Int.pipe(Schema.greaterThanOrEqualTo(0))),
})

TypeBox

import { Type, type Static } from '@sinclair/typebox'

export const User = Type.Object({
  name: Type.String(),
  email: Type.String({ format: 'email' }),
  age: Type.Optional(Type.Integer({ minimum: 0 })),
})

Arktype

import { type } from 'arktype'

export const User = type({
  name: 'string',
  email: 'string.email',
  'age?': 'number.integer >= 0',
})

With --export-type, type exports are also generated:

// Zod
export type User = z.infer<typeof User>

// Valibot
export type UserOutput = v.InferOutput<typeof User>

// Effect Schema
export type UserEncoded = typeof User.Encoded

// TypeBox
export type User = Static<typeof User>

// Arktype
export type User = typeof User.infer

License

Distributed under the MIT License. See LICENSE for more information.