[!CAUTION] This project is now deprecated as Valibot now has an official JSON schema converter in the @valibot/to-json-schema. The command line interface is moved to the project @gcornut/cli-valibot-to-json-schema.

@gcornut/valibot-json-schema

CLI and JS utility to convert Valibot schemas to JSON schema (draft 07).

Some of the features of Valibot can't be converted to JSON schema. JS-specific types like blob or nan obviously can't have an equivalent.
See supported features for more info.

Command Line Tool

This lib exports a CLI that can be used to quickly convert JS modules defining valibot schemas into a JSON schema.

1# Convert valibot schemas to JSON schema
2npx @gcornut/valibot-json-schema to-json-schema ./schemas.js

This outputs a conversion of the Valibot schemas into JSON schema. If the default export is a Valibot schemas, it is used as the root definition. Other exported Valibot schemas are converted in the JSON schema definitions section.

1import * as v from 'valibot';
2
3export const AString = v.string();
4const AnObject = v.object({ aString: AString });
5export default AnObject;

1{
2  "$schema": "http://json-schema.org/draft-07/schema#",
3  "definitions": {
4    "AString": {
5      "type": "string"
6    }
7  },
8  "properties": {
9    "aString": {
10      "$ref": "#/definitions/AString"
11    }
12  },
13  "required": [
14    "aString"
15  ],
16  "type": "object"
17}

ESM and TypeScript input module

The valibot-json-schema CLI loads the input JS module using standard NodeJS CommonJS require. This means you will have issues with ESM or TypeScript modules.

To remedy that, you will either have to preinstall ebuild-runner and esbuild (so that the program can use them) or use a Node-compatible runtime that support these modules (ex: bun, replacing npx with bunx).

Example:

1# Convert from TS/ESM module using bunx
2bunx @gcornut/valibot-json-schema to-json-schema ./schemas.ts
3
4# Convert from TS/ESM module with esbuild-runner preinstalled
5npm install esbuild esbuild-runner
6npx @gcornut/valibot-json-schema to-json-schema ./schemas.ts
7
8# Convert from TS/ESM module using `yarn dlx` multi-package feature 
9yarn dlx -p esbuild -p esbuild-runner -p @gcornut/valibot-json-schema valibot-json-schema to-json-schema ./schemas.ts

CLI parameters

Use -o <file> option to output the JSON schema to a file instead of stdout.

Use -t <type> option to select the root definitions from the module exports (defaults to the "default" export). Example: -t foo.bar will get the property bar on the foo export of the input JS module.

Use -d <type> option to select the definitions from the module exports (instead of using all non-default export). Example: -d foo.bar will get the property bar on the foo export of the input JS module.

See Advanced options for more options.

Programmatic usage

Use the toJSONSchema function to convert a Valibot schema into JSON schema (v7):

1import { toJSONSchema } from '@gcornut/valibot-json-schema';
2import { string } from 'valibot';
3
4toJSONSchema({ schema: string() })
5// {
6//    $schema: 'http://json-schema.org/draft-07/schema#',
7//    type: 'string',
8// }

If you have many named schemas to convert, you can use the definitions option schema to list as a plain object so that both the schema names (object keys) and schema definitions (object values) are exported to JSON schema.

1import { toJSONSchema } from '@gcornut/valibot-json-schema';
2import { number } from 'valibot';
3
4const Number = number();
5toJSONSchema({ definitions: { Number } });
6// {
7//    $schema: 'http://json-schema.org/draft-07/schema#',
8//    definitions: { Number: { type: 'number' } },
9// }

See Advanced options for more options.

Advanced options

Strict object types

Using the strictObjectTypes option (--strictObjectTypes in the CLI), you can force all object type block unknown keys (additionalProperties: false).

Ignore unknown validation

You might want to have advanced validation in your valibot schema that JSON schema can't support ( like custom()). By default, toJSONSchema() will throw an error to let you know these can't be converted to JSON schema.

Using the ignoreUnknownValidation option (--ignoreUnknownValidation in the CLI), you can ignore unsupported valibot validations.

If you preferred to only ignore a specific type of validation, you can use the customValidationConversion option.

Common type strategies

Many JS types don't have a direct equivalent in JSON and toJSONSchema() will throw an error when encountering any of those. However, some of these types have common strategies to convert them.

Using the dateStrategy option (--dateStrategy in the CLI), you can choose to convert JS Date objects into a string ( with the date-time format) or into an integer (with the unix-time format).

Using the undefinedStrategy option (--undefinedStrategy in the CLI), you can choose to convert undefined to the " any" schema (no validation) or to the null type.

Using the bigintStrategy option (--bigintStrategy in the CLI), you can choose to convert JS BigInt values to an integer (with the int64 format) or into a string.

Custom schema conversion

In some cases, you might want to provide custom schema conversion to override standard schema conversion or to add conversion of unsupported schemas.

Using the customSchemaConversion option, you can provide a custom schema converter for any valibot schema type.

Example: converting JS Set schema into an array schema

1import { set, string } from 'valibot';
2
3toJSONSchema({
4    schema: set(string()),
5    customSchemaConversion: {
6        // Treat set type like an array
7        set: (schema, converter) => converter(array(schema.value))
8    },
9})
10// => { type: 'array', items: { type: 'string' } }

Custom validation conversion

Using the customValidationConversion option, you can provide a custom validation converter for any valibot validation type.

Example: ignoring the valibot custom() validation on all string schema

1import { string, custom, pipe } from 'valibot';
2
3toJSONSchema({
4    schema: pipe(string(), custom(myCustomStringValidation)),
5    customValidationConversion: {
6        string: { custom: () => ({}) }
7    },
8})
9// => { type: 'string' }

Supported features

Some converted schema might have slightly different behavior in a JSON schema validator, especially on string formats (email, ipv4, date, etc.) since their implementation is different from valibot implementation.

Here is the list of supported Valibot features (some have partial support):