ultimo 0.4.0

Modern Rust web framework with automatic TypeScript client generation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

//! Validation helpers for request data
//!
//! Integrates with the validator crate to provide automatic validation
//! with structured error responses.

use crate::error::{Result, UltimoError, ValidationError};
use validator::{Validate, ValidationErrors};

/// Validate a struct and convert errors to UltimoError
pub fn validate<T: Validate>(data: &T) -> Result<()> {
    data.validate().map_err(|errors| UltimoError::Validation {
        message: "Validation failed".to_string(),
        details: validation_errors_to_details(errors),
    })
}

/// Convert validator ValidationErrors to our ValidationError format
fn validation_errors_to_details(errors: ValidationErrors) -> Vec<ValidationError> {
    let mut details = Vec::new();

    for (field, field_errors) in errors.field_errors() {
        for error in field_errors {
            let message = error
                .message
                .as_ref()
                .map(|m| m.to_string())
                .unwrap_or_else(|| format!("Validation failed for field: {}", field));

            details.push(ValidationError {
                field: field.to_string(),
                message,
            });
        }
    }

    details
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde::Deserialize;
    use validator::Validate;

    #[derive(Debug, Deserialize, Validate)]
    struct TestData {
        #[validate(length(min = 3, max = 10))]
        name: String,
        #[validate(email)]
        email: String,
    }

    #[test]
    fn test_validation_success() {
        let data = TestData {
            name: "John".to_string(),
            email: "john@example.com".to_string(),
        };

        assert!(validate(&data).is_ok());
    }

    #[test]
    fn test_validation_failure() {
        let data = TestData {
            name: "AB".to_string(),       // Too short
            email: "invalid".to_string(), // Invalid email
        };

        let result = validate(&data);
        assert!(result.is_err());

        if let Err(UltimoError::Validation { details, .. }) = result {
            assert!(!details.is_empty());
        } else {
            panic!("Expected ValidationError");
        }
    }
}