Popularity
1.4
Growing
Activity
8.8
Stable
18
4
3

Description

A JSON Schema validator implementation. It compiles schema into a validation tree to have validation as fast as possible.

Programming language: Rust
Latest version: v0.3.1

jsonschema alternatives and similar packages

Based on the "Miscellaneous" category

Do you think we are missing an alternative of jsonschema or a related project?

Add another 'Miscellaneous' Package

README

jsonschema

ci codecov Crates.io docs.rs

A JSON Schema validator implementation. It compiles schema into a validation tree to have validation as fast as possible.

Supported drafts:

  • Draft 7
  • Draft 6
  • Draft 4 (except optional bignum.json test case)
# Cargo.toml
jsonschema = "0.3"

To validate documents against some schema and get validation errors (if any):

use jsonschema::{JSONSchema, Draft};
use serde_json::json;

fn main() {
    let schema = json!({"maxLength": 5});
    let instance = json!("foo");
    let compiled = JSONSchema::compile(&schema, Some(Draft::Draft7));
    let result = compiled.validate(&instance);
    if let Err(errors) = result {
        for error in errors {
            println!("Validation error: {}", error)
        }   
    }
}

If you only need to know whether document is valid or not (which is faster):

use jsonschema::is_valid;
use serde_json::json;

fn main() {
    let schema = json!({"maxLength": 5});
    let instance = json!("foo");
    assert!(is_valid(&schema, &instance));
}

Or use a compiled schema (preferred):

use jsonschema::{JSONSchema, Draft};
use serde_json::json;

fn main() {
    let schema = json!({"maxLength": 5});
    let instance = json!("foo");
    // Draft is detected automatically with fallback to Draft7
    let compiled = JSONSchema::compile(&schema, None);
    assert!(compiled.is_valid(&instance));
}

Performance

There is a comparison with other JSON Schema validators written in Rust - jsonschema_valid and valico.

Test machine i8700K (12 cores), 32GB RAM.

Performance of jsonschema::JSONSchema.is_valid. Ratios are given against compiled jsonschema:

  • Big valid input (canada_schema.json and canada.json)
  • Small valid input (small_schema.json and small_valid.json)
  • Small invalid input (small_schema.json and small_invalid.json)
Case jsonschema_valid valico jsonschema
Big valid 56.746 ms (x185.65) 149.49 ms (x489.07) 305.66 us
Small valid 2.23 us (x17.15) 3.87 us (x29.77) 129.97 ns
Small invalid 515.22 ns (x96.3) 4.08 us (x762.61) 5.35 ns

All libraries were used in their "compiled" form, where a validator is prepared before usage. Here is comparison when a validator is compiled every time.

Case jsonschema_valid valico jsonschema
Big valid 56.714 ms (x183.72) 146.82 ms (x475.62) 308.69 us
Small valid 3.02 us (x1.13) 118.09 us (x44.22) 2.67 us
Small invalid 1.17 us (x0.46) 81.95 us (x32.26) 2.54 us

You can find benchmark code in benches/jsonschema.rs, Rust version is 1.44

NOTE. This library is in early development.