Serde Valid
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,
}
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());