Crate serde_valid
source · [−]Expand description
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,
}
// 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 method
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());
Re-exports
pub use error::Error;
Modules
Structs
Traits
Enumerate validation.
Exclusive maximum of the number validation.
Exclusive minimum of the number validation.
Max length of the array items validation.
Max length of the string validation.
Max size of the object properties validation.
Maximum of the number validation.
Min length of the array items validation.
Min length of the string validation.
Min size of the object properties validation.
Minimum of the number validation.
Multipl of the number validation.
Pattern of the string validation.
Uniqueness of the array items validation.