Valitron is an ergonomic, functional and configurable validator

In the future, modularization will be supported

Inspired by axum

Features

• Ergonomics validation
• Build-in rule, e.g. Required, StartWith ...
• Closure validate
• Related validate, e.g. password confirm
• Custom rule with other parameter
• Check / modify input data
• Custom error message type
• Support different error types convert, it can use both build-in rules and custom error type simultaneously
• Collect validate error messages
• Support all types data on #[derive(Serialize, Deserialize)] ( visit serde for more info)

Example 1

fn main() {
    let validator = Validator::new()
        .rule("name", Required.and(StartWith("hello")))
        .rule("age", custom(age_limit))
        .message([
            ("name.required", "name is required"),
            ("name.start_with", "name should be starts with `hello`"),
        ]);

    let person = Person {
        name: "li",
        age: 18,
    };

    let res = validator.validate(person);
    // or using trait
    let res = person.validate(validator);
}

fn age_limit(n: &mut u8) -> Result<(), Message> {
    if *n >= 25 && *n <= 45 {
        return Ok(());
    }
    Err("age should be between 25 and 45".into())
}

Example 2

use valitron::register::string::Validator;
impl Input {
    fn new(mut input: Input) -> Result<Self, Validator<Message>> {
        let valid = Validator::new()
            .insert("name", &mut input.name, Trim.and(Required))
            .insert("email", &mut input.email, Trim.and(Required).and(Email))
            .insert("gender", &mut input.gender, custom(validate_gender))
            .insert(
                "password",
                &mut input.password,
                Trim.custom(validate_password),
            )
            .insert_fn("age", || {
                if input.age < 10 {
                    input.age = 10;
                }
                if input.age > 18 {
                    Err(Message::fallback("age is out of range"))
                } else {
                    Ok(())
                }
            });

        valid.validate(input)
    }
}
fn validate_password(pass: &mut String) -> Result<(), Message> {
    todo!()
}

fn validate_gender(gender: &mut String) -> Result<(), Message> {
    Ok(())
}

Document

Rules Usage

Bench

License