jsl 
Documentation on docs.rs: https://docs.rs/jsl
This crate is a Rust implementation of JSON Schema Language. You can use it to:
- Validate input data is valid against a schema,
- Get a list of validation errors with that input data, or
- Build your own custom tooling on top of JSON Schema Language.
About JSON Schema Language
JSON Schema Language ("JSL") lets you define schemas for JSON data, or data that's equivalent to JSON (such a subset of YAML, CBOR, BSON, etc.). Using those schemas, you can:
- Validate that inputted JSON data is correctly formatted
- Document what kind of data you expect to recieve or produce
- Generate code, documentation, or user interfaces automatically
- Generate interoperable, detailed validation errors
JSON Schema Language is designed to make JSON more productive. For that reason, it's super lightweight and easy to implement. It's designed to be intuitive and easy to extend for your custom use-cases.
For more information, see: https://json-schema-language.github.io.
Usage
The detailed documentation on docs.rs goes into more detail, but at a high level here's how you use this crate to validate inputted data:
use serde_json::json;
use jsl::{Schema, SerdeSchema, Validator, ValidationError};
use failure::Error;
use std::collections::HashSet;
fn main() -> Result<(), Error> {
let demo_schema_data = r#"
{
"properties": {
"name": { "type": "string" },
"age": { "type": "number" },
"phones": {
"elements": { "type": "string" }
}
}
}
"#;
// The SerdeSchema type is a serde-friendly format for representing
// schemas.
let demo_schema: SerdeSchema = serde_json::from_str(demo_schema_data)?;
// The Schema type is a higher-level format that does more validity
// checks.
let demo_schema = Schema::from_serde(demo_schema).unwrap();
// Validator can quickly check if an instance satisfies some schema.
// With the new_with_config constructor, you can configure how many
// errors to return, and how to handle the possibility of a
// circularly-defined schema.
let validator = Validator::new();
let input_ok = json!({
"name": "John Doe",
"age": 43,
"phones": [
"+44 1234567",
"+44 2345678"
]
});
let validation_errors_ok = validator.validate(&demo_schema, &input_ok)?;
assert!(validation_errors_ok.is_empty());
let input_bad = json!({
"age": "43",
"phones": [
"+44 1234567",
442345678
]
});
// Each ValidationError holds paths to the bad part of the input, as
// well as the part of the schema which rejected it.
//
// For testing purposes, we'll sort the errors so that their order is
// predictable.
let mut validation_errors_bad = validator.validate(&demo_schema, &input_bad)?;
validation_errors_bad.sort_by_key(|err| err.instance_path().to_string());
assert_eq!(validation_errors_bad.len(), 3);
// "name" is required
assert_eq!(validation_errors_bad[0].instance_path().to_string(), "");
assert_eq!(validation_errors_bad[0].schema_path().to_string(), "/properties/name");
// "age" has the wrong type
assert_eq!(validation_errors_bad[1].instance_path().to_string(), "/age");
assert_eq!(validation_errors_bad[1].schema_path().to_string(), "/properties/age/type");
// "phones[1]" has the wrong type
assert_eq!(validation_errors_bad[2].instance_path().to_string(), "/phones/1");
assert_eq!(validation_errors_bad[2].schema_path().to_string(), "/properties/phones/elements/type");
Ok(())
}
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent