validator Rust Library

When validation fails, validate() returns ValidationErrors. The errors are categorized by the ValidationErrorsKind enum, which determines how errors are nested:

• Struct(Box<ValidationErrors>): Used for errors found in a single nested struct (via #[validate(nested)]).
• List(BTreeMap<usize, Box<ValidationErrors>>): Used for errors found in a vector of nested structs, keyed by the index of the invalid entry.
• Field(Vec<ValidationError>): Used for simple field-level errors.

A ValidationError contains:

• code: A Cow<'static, str> representing the error type.
• message: An optional Cow<'static, str> describing the error.
• params: A HashMap<Cow<'static, str>, Value> containing metadata, including the field's value automatically.

#[derive(Debug, Serialize, Clone, PartialEq)]
#[serde(untagged)]
pub enum ValidationErrorsKind {
    Struct(Box<ValidationErrors>),
    List(BTreeMap<usize, Box<ValidationErrors>>),
    Field(Vec<ValidationError>),
}

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
pub struct ValidationError {
  pub code: Cow<'static, str>,
  pub message: Option<Cow<'static, str>>,
  pub params: HashMap<Cow<'static, str>, Value>,
}

You can define custom validation logic in two ways:

1. Simple Custom Function

Pass a function name to #[validate(custom(function = "..."))]. The function must accept the field value and return Result<(), ValidationError>.

2. Custom Validation with Context (Arguments)

To pass external data (like a database connection) to your validator, use the context and use_context attributes.

1. Define a context struct.
2. Use #[validate(context = Type)] on the struct being validated.
3. Use #[validate(custom(function = "...", use_context))] on the field.
4. Call .validate_with_args(&context) instead of .validate().

Note: Custom validation with arguments does not work on nested validation.

use validator::{Validate, ValidateArgs, ValidationError};

fn validate(value: &str, context: &TestContext) -> Result<(), ValidationError> {
    // ... logic
    Ok(())
}

struct TestContext(i64, i64);

#[derive(Debug, Validate)]
#[validate(context = TestContext)]
struct TestStruct {
    #[validate(custom(function = "validate", use_context))]
    value: String,
}

let test_struct = TestStruct { value: "..." };
let test_context = TestContext(1, 2);
test_struct.validate_with_args(&test_context).is_ok();

The Validate derive macro allows you to define validation rules directly on struct fields using #[validate(...)] attributes. To perform validation, call the .validate() method on your struct instance, which returns a Result<(), ValidationErrors>.

use serde::Deserialize;
use validator::{Validate, ValidationError};

#[derive(Debug, Validate, Deserialize)]
struct SignupData {
    #[validate(email)]
    mail: String,
    #[validate(url)]
    site: String,
    #[validate(length(min = 1), custom(function = "validate_unique_username"))]
    #[serde(rename = "firstName")]
    first_name: String,
    #[validate(range(min = 18, max = 20))]
    age: u32,
    #[validate(range(exclusive_min = 0.0, max = 100.0))]
    height: f32,
}

fn validate_unique_username(username: &str) -> Result<(), ValidationError> {
    if username == "xXxShad0wxXx" {
        return Err(ValidationError::new("terrible_username"));
    }
    Ok(())
}

// Usage:
match signup_data.validate() {
  Ok(_) => (),
  Err(e) => return e,
};

The ValidateLength<u64> trait is implemented for a wide variety of standard Rust types. The method of length calculation depends on the type:

Character-based length (Unicode characters)

Used for types where length is defined by the number of characters:

• str and &str
• String

Element-based length (Number of elements)

Used for collections where length is defined by the number of items/elements:

• Vec<T>
• [T; N] (Arrays)
• VecDeque<T>
• BTreeSet<T>
• BTreeMap<K, V>
• HashSet<T, S>
• HashMap<K, V, S>
• IndexSet<T> (with indexmap feature)
• IndexMap<K, V> (with indexmap feature)
• Slices [T]

Wrapper types

• Option<T>: If Some(val), it validates the length of val. If None, it returns true (as length is None).
• Cow<'_, T>: Delegates to the underlying type.
• Smart Pointers: Arc<T>, Box<T>, Rc<T>, Ref<'_, T>, and RefMut<'_, T> all delegate to the inner type T.