Struct AsyncValidator 

pub struct AsyncValidator<'a> { /* private fields */ }

Async request validator.

Mirrors crate::validation::Validator ergonomics while adding support for Box<dyn AsyncRule> rules (e.g. DB uniqueness checks). Sync rules run first; async rules run only on fields with no sync error (fail-fast, D-03).

Example

use ferro_rs::{AsyncValidator, AsyncValidationError, unique};
use ferro_rs::validation::rules::*;
use ferro_rs::rules;

let data = req.input::<serde_json::Value>().await?;
match AsyncValidator::new(&data)
    .rules("slug", rules![required(), string()])
    .async_rule("slug", unique("articles", "slug"))
    .validate_async()
    .await
{
    Ok(()) => {}
    Err(AsyncValidationError::Validation(e)) => {
        return Err(e.with_old_input(&data).into_action_error("/articles/new"));
    }
    Err(AsyncValidationError::Infra(fe)) => {
        return Err(fe.into());
    }
}

Implementations

impl<'a> AsyncValidator<'a>

pub fn new(data: &'a Value) -> Self

Create a new async validator for the given data.

pub fn rule<R: Rule + 'static>(self, field: impl Into<String>, rule: R) -> Self

Add a single sync validation rule for a field.

pub fn rules(self, field: impl Into<String>, rules: Vec<Box<dyn Rule>>) -> Self

Add multiple sync validation rules for a field using boxed rules.

Example

use ferro_rs::rules;
use ferro_rs::validation::rules::*;

AsyncValidator::new(&data)
    .rules("email", rules![required(), email()])
    .rules("name", rules![required(), string(), max(255)]);

pub fn async_rule<R: AsyncRule + 'static>( self, field: impl Into<String>, rule: R, ) -> Self

Add a single async validation rule for a field.

Async rules run only after all sync rules pass for the field (D-03).

pub fn message(self, key: impl Into<String>, message: impl Into<String>) -> Self

Set a custom error message for a field.rule combination.

Example

AsyncValidator::new(&data)
    .rules("email", rules![required(), email()])
    .message("email.required", "Please provide your email address");

pub fn messages(self, messages: HashMap<String, String>) -> Self

Set custom messages from a map.

pub fn attribute( self, field: impl Into<String>, name: impl Into<String>, ) -> Self

Set a custom attribute name for a field.

Example

AsyncValidator::new(&data)
    .rules("email", rules![required()])
    .attribute("email", "email address");
// Error: "The email address field is required."

pub fn attributes(self, attributes: HashMap<String, String>) -> Self

Set custom attributes from a map.

pub async fn validate_async(self) -> Result<(), AsyncValidationError>

Run async validation. Returns:

• Ok(()) — all rules pass.
• Err(AsyncValidationError::Validation(e)) — field-level failures.
• Err(AsyncValidationError::Infra(e)) — DB/infra failure (handler → 500).

Execution order (D-03)

Phase 1: all sync rules run across all fields. Phase 2: async rules run only on fields with no sync error — no DB query is issued for an already-failed field.

Infra sentinel (D-12)

An async rule that returns Err(msg) where msg starts with __infra_error__: is treated as an infrastructure failure, not a field error. The stripped message is wrapped in AsyncValidationError::Infra(FrameworkError::database(...)) and returned immediately.