#validation #serde #json-schema

macro serde_valid_derive

JSON Schema based validation tool using with serde

3 unstable releases

Uses new Rust 2021

0.2.0 May 13, 2022
0.1.1 May 10, 2022
0.1.0 May 10, 2022

#544 in Encoding

Download history 110/week @ 2022-05-10 18/week @ 2022-05-17 17/week @ 2022-05-24 30/week @ 2022-05-31 12/week @ 2022-06-07 16/week @ 2022-06-14 5/week @ 2022-06-21

65 downloads per month
Used in serde_valid

MIT license

98KB
2.5K SLoC

Serde Valid

Latest Version GitHub license

This is JSON Schema based validation tool using with serde.

Usage

You derive Validate trait, and write validations.

use serde_valid::Validate;

#[derive(Validate)]
struct SampleStruct {
    #[validate(minimum = 0)]
    #[validate(maximum = 10)]
    val: i32,
}

#[derive(Validate)]
enum SampleEnum {
    Named {
        #[validate]
        a: SampleStruct,
    },
    UnNamed(
        #[validate(minimum = 0)]
        #[validate(maximum = 10)]
        i32,
    ),
}

let s = SampleEnum::Named {
    a: SampleStruct { val: 5 },
};

assert!(s.validate().is_ok());

Validations

Serde Valid support standard validation based JSON Schema.

Type Serde Valid(validate derive) Json Schema
String #[validate(max_length = 5)] maxLength
String #[validate(min_length = 5)] minLength
String #[validate(pattern = r"^\d{5}$")] pattern
Numeric #[validate(maximum = 5)] maximum
Numeric #[validate(minimum = 5)] minimum
Numeric #[validate(exclusive_maximum = 5)] exclusiveMaximum
Numeric #[validate(exclusive_minimum = 5)] exclusiveMinimum
Numeric #[validate(multiple_of = 5)] multipleOf
Object #[validate(max_properties = 5)] maxProperties
Object #[validate(min_properties = 5)] minProperties
Array #[validate(max_items = 5)] maxItems
Array #[validate(min_items = 5)] minItems
Array #[validate(unique_items)] uniqueItems
Generic #[validate(enumerate(5, 10, 15))] enum

Complete Constructor (Deserialization)

Serde Valid support complete constructor method using by serde_valid::json::FromJson trait.

use serde::Deserialize;
use serde_valid::Validate;
use serde_valid::json::{json, FromJson};

#[derive(Debug, Deserialize, Validate)]
struct SampleStruct {
    #[validate(maximum = 100)]
    val: i32,
}

// Deserialization and Validation!! πŸš€
let err = SampleStruct::from_json_value(json!({ "val": 123 })).unwrap_err();

assert_eq!(
    serde_json::to_value(err.as_validation_errors().unwrap()).unwrap(),
    json!({ "val": [ "the number must be `<= 100`." ] })
);

You can force validation by only deserialization through serde_valid, and removing serde_json from Cargo.toml of your project.

Serialization

For serialization, provides serde_valid::json::ToJson trait.

use serde::Serialize;
use serde_valid::Validate;
use serde_valid::json::{json, ToJson};

#[derive(Debug, Serialize, Validate)]
struct SampleStruct {
    #[validate(maximum = 100)]
    val: i32,
}

assert_eq!(
    SampleStruct{ val: 12i32 }.to_json_string().unwrap(),
    json!({ "val": 12i32 }).to_json_string().unwrap()
);

Custom Message

For user custom message, Serde Valid provides message_fn or message.

use serde_json::json;
use serde_valid::Validate;

fn min_error_message(_params: &serde_valid::MinItemsErrorParams) -> String {
    "this is min custom message_fn.".to_string()
}

#[derive(Validate)]
struct SampleStruct {
    #[validate(min_items = 4, message_fn(min_error_message))]
    #[validate(max_items = 2, message = "this is max custom message.")]
    val: Vec<i32>,
}

let s = SampleStruct { val: vec![1, 2, 3] };

assert_eq!(
    serde_json::to_string(&s.validate().unwrap_err()).unwrap(),
    serde_json::to_string(&json!({
        "val": [
            "this is min custom message_fn.",
            "this is max custom message."
        ]
    }))
    .unwrap()
);

Custom Validation

You can use your custom validation using by #[validate(custom)].

use serde_valid::Validate;

fn user_validation(_val: &i32) -> Result<(), serde_valid::validation::Error> {
    Ok(())
}

#[derive(Validate)]
struct SampleStruct {
    #[validate(custom(user_validation))]
    val: i32,
}

let s = SampleStruct { val: 1 };

assert!(s.validate().is_ok());

Rules

If you want to check multi fields validation, you can use #[rule].

use serde_json::json;
use serde_valid::Validate;

fn sample_rule(_val1: &i32, _val2: &str) -> Result<(), serde_valid::validation::Error> {
    Err(serde_valid::validation::Error::Custom(
        "Rule error is added to the first arg of the rule_method.".to_owned(),
    ))
}

#[derive(Validate)]
#[rule(sample_rule(val2, val1))]
struct SampleStruct {
    val1: String,
    val2: i32,
}

let s = SampleStruct {
    val1: "val1".to_owned(),
    val2: 1,
};

assert_eq!(
    serde_json::to_string(&s.validate().unwrap_err()).unwrap(),
    serde_json::to_string(&json!({
        "val2": [
            "Rule error is added to the first arg of the rule_method."
        ]
    }))
    .unwrap()
);

If you want to use rule to unnamed fields struct, just like this,

use serde_json::json;
use serde_valid::Validate;

fn sample_rule(_val1: &i32, _val2: &str) -> Result<(), serde_valid::validation::Error> {
    Ok(())
}

#[derive(Validate)]
#[rule(sample_rule(0, 1))]
struct SampleStruct(i32, String);

let s = SampleStruct(0, "1".to_owned());

assert!(s.validate().is_ok());

Validate Traits

By implementing the validation trait, Your original type can uses Serde Valid validations.

use serde_valid::Validate;

struct MyType(String);

impl serde_valid::ValidateMaxLength for MyType {
    fn validate_max_length(&self, max_length: usize) -> Result<(), serde_valid::MaxLengthErrorParams> {
        self.0.validate_max_length(max_length)
    }
}

impl serde_valid::ValidateMinLength for MyType {
    fn validate_min_length(&self, min_length: usize) -> Result<(), serde_valid::MinLengthErrorParams> {
        self.0.validate_min_length(min_length)
    }
}

#[derive(Validate)]
struct SampleStruct {
    #[validate(min_length = 5)]
    #[validate(max_length = 5)]
    val: MyType,
}

let s = SampleStruct {
    val: MyType(String::from("πŸ˜πŸ‘ΊπŸ™‹πŸ½πŸ‘¨β€πŸŽ€πŸ‘¨β€πŸ‘©β€πŸ‘§β€πŸ‘¦")),
};

assert!(s.validate().is_ok());

Dependencies

~315–740KB
~17K SLoC