feat: add json-schema support

Author: kerwanp

package.json

@@ -47,6 +47,7 @@
     "@release-it/conventional-changelog": "^10.0.1",
     "@swc/core": "1.10.7",
     "@types/dlv": "^1.1.5",
+    "@types/json-schema": "^7.0.15",
     "@types/node": "^22.15.2",
     "benchmark": "^2.1.4",
     "c8": "^10.1.3",

src/schema/any/main.ts

@@ -8,8 +8,10 @@
  */
 
 import { BaseLiteralType } from '../base/literal.js'
-import type { FieldOptions, Validation } from '../../types.js'
-import { SUBTYPE } from '../../symbols.js'
+import type { FieldOptions, ParserOptions, Validation } from '../../types.js'
+import { PARSE, SUBTYPE } from '../../symbols.js'
+import { RefsStore, LiteralNode } from '@vinejs/compiler/types'
+import { JSONSchema7 } from 'json-schema'
 
 /**
  * VineAny represents a value that can be anything
@@ -31,4 +33,36 @@ export class VineAny extends BaseLiteralType<any, any, any> {
   clone(): this {
     return new VineAny(this.cloneOptions(), this.cloneValidations()) as this
   }
+
+  protected compileJsonSchema(): JSONSchema7 {
+    const schema: JSONSchema7 = {
+      anyOf: [
+        { type: 'string' },
+        { type: 'number' },
+        { type: 'boolean' },
+        { type: 'array' },
+        { type: 'object' },
+      ],
+    }
+
+    for (const validation of this.validations) {
+      if (!validation.rule.jsonSchema) continue
+      validation.rule.jsonSchema(schema, validation.options)
+    }
+
+    return schema
+  }
+
+  /**
+   * Compiles the schema type to a compiler node
+   */
+  [PARSE](
+    propertyName: string,
+    refs: RefsStore,
+    options: ParserOptions
+  ): LiteralNode & { subtype: string; json: JSONSchema7 } {
+    const schema = super[PARSE](propertyName, refs, options)
+    schema.json = this.compileJsonSchema()
+    return schema
+  }
 }

src/schema/array/main.ts

@@ -12,7 +12,13 @@ import { RefsStore, ArrayNode } from '@vinejs/compiler/types'
 
 import { BaseType } from '../base/main.js'
 import { ITYPE, OTYPE, COTYPE, PARSE, UNIQUE_NAME, IS_OF_TYPE } from '../../symbols.js'
-import type { FieldOptions, ParserOptions, SchemaTypes, Validation } from '../../types.js'
+import type {
+  CompilerNodes,
+  FieldOptions,
+  ParserOptions,
+  SchemaTypes,
+  Validation,
+} from '../../types.js'
 
 import {
   compactRule,
@@ -22,6 +28,7 @@ import {
   maxLengthRule,
   fixedLengthRule,
 } from './rules.js'
+import { JSONSchema7 } from 'json-schema'
 
 /**
  * VineArray represents an array schema type in the validation
@@ -114,20 +121,46 @@ export class VineArray<Schema extends SchemaTypes> extends BaseType<
     return new VineArray(this.#schema.clone(), this.cloneOptions(), this.cloneValidations()) as this
   }
 
+  /**
+   * Compiles JSON Schema.
+   */
+  protected compileJsonSchema(node: CompilerNodes) {
+    const schema: JSONSchema7 = {
+      type: 'array',
+    }
+
+    if ('json' in node) {
+      schema.items = node.json
+    }
+
+    for (const validation of this.validations) {
+      if (!validation.rule.jsonSchema) continue
+      validation.rule.jsonSchema(schema, validation.options)
+    }
+
+    return schema
+  }
+
   /**
    * Compiles to array data type
    */
-  [PARSE](propertyName: string, refs: RefsStore, options: ParserOptions): ArrayNode {
+  [PARSE](
+    propertyName: string,
+    refs: RefsStore,
+    options: ParserOptions
+  ): ArrayNode & { json: JSONSchema7 } {
+    const parsed = this.#schema[PARSE]('*', refs, options)
     return {
       type: 'array',
       fieldName: propertyName,
       propertyName: options.toCamelCase ? camelcase(propertyName) : propertyName,
       bail: this.options.bail,
       allowNull: this.options.allowNull,
       isOptional: this.options.isOptional,
-      each: this.#schema[PARSE]('*', refs, options),
+      each: parsed,
       parseFnId: this.options.parse ? refs.trackParser(this.options.parse) : undefined,
       validations: this.compileValidations(refs),
+      json: this.compileJsonSchema(parsed),
     }
   }
 }

src/schema/array/rules.ts

@@ -14,26 +14,40 @@ import { createRule } from '../../vine/create_rule.js'
 /**
  * Enforce a minimum length on an array field
  */
-export const minLengthRule = createRule<{ min: number }>(function minLength(value, options, field) {
-  /**
-   * Value will always be an array if the field is valid.
-   */
-  if ((value as unknown[]).length < options.min) {
-    field.report(messages['array.minLength'], 'array.minLength', field, options)
+export const minLengthRule = createRule<{ min: number }>(
+  function minLength(value, options, field) {
+    /**
+     * Value will always be an array if the field is valid.
+     */
+    if ((value as unknown[]).length < options.min) {
+      field.report(messages['array.minLength'], 'array.minLength', field, options)
+    }
+  },
+  {
+    json: (schema, options) => {
+      schema.minItems = options.min
+    },
   }
-})
+)
 
 /**
  * Enforce a maximum length on an array field
  */
-export const maxLengthRule = createRule<{ max: number }>(function maxLength(value, options, field) {
-  /**
-   * Value will always be an array if the field is valid.
-   */
-  if ((value as unknown[]).length > options.max) {
-    field.report(messages['array.maxLength'], 'array.maxLength', field, options)
+export const maxLengthRule = createRule<{ max: number }>(
+  function maxLength(value, options, field) {
+    /**
+     * Value will always be an array if the field is valid.
+     */
+    if ((value as unknown[]).length > options.max) {
+      field.report(messages['array.maxLength'], 'array.maxLength', field, options)
+    }
+  },
+  {
+    json: (schema, options) => {
+      schema.maxItems = options.max
+    },
   }
-})
+)
 
 /**
  * Enforce a fixed length on an array field
@@ -46,20 +60,33 @@ export const fixedLengthRule = createRule<{ size: number }>(
     if ((value as unknown[]).length !== options.size) {
       field.report(messages['array.fixedLength'], 'array.fixedLength', field, options)
     }
+  },
+  {
+    json: (schema, options) => {
+      schema.minItems = options.size
+      schema.maxItems = options.size
+    },
   }
 )
 
 /**
  * Ensure the array is not empty
  */
-export const notEmptyRule = createRule<undefined>(function notEmpty(value, _, field) {
-  /**
-   * Value will always be an array if the field is valid.
-   */
-  if ((value as unknown[]).length <= 0) {
-    field.report(messages.notEmpty, 'notEmpty', field)
+export const notEmptyRule = createRule<undefined>(
+  function notEmpty(value, _, field) {
+    /**
+     * Value will always be an array if the field is valid.
+     */
+    if ((value as unknown[]).length <= 0) {
+      field.report(messages.notEmpty, 'notEmpty', field)
+    }
+  },
+  {
+    json: (schema) => {
+      schema.minItems = 1
+    },
   }
-})
+)
 
 /**
  * Ensure array elements are distinct/unique
@@ -72,6 +99,11 @@ export const distinctRule = createRule<{ fields?: string | string[] }>(
     if (!helpers.isDistinct(value as any[], options.fields)) {
       field.report(messages.distinct, 'distinct', field, options)
     }
+  },
+  {
+    json: (schema) => {
+      schema.uniqueItems = true
+    },
   }
 )