valida 1.1.2

Modular validation system for Rust with support for nested structures and localization.
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use crate::core::contract::{IValidatorRuleCustom, IValidatorRuleCustomAsync};
use crate::core::field_builder::main::FieldBuilder;
use std::error::Error;

impl<'a, T, V, E> FieldBuilder<'a, T, V, E>
where
    V: 'static,
    E: Error + Send + Sync + 'static,
{
    pub fn custom_async<R>(mut self, rule: R) -> Self
    where
        R: IValidatorRuleCustomAsync<V, E> + Send + Sync + 'static,
    {
        self.rules.rules_custom_async.push(Box::new(rule));
        self
    }
}

impl<'a, T, V, E> FieldBuilder<'a, T, V, E>
where
    V: 'static,
    E: Error + Send + Sync + 'static,
{
    pub fn custom<R>(mut self, rule: R) -> Self
    where
        R: IValidatorRuleCustom<V, E> + Send + Sync + 'static,
    {
        self.rules.rules_custom.push(Box::new(rule));
        self
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use async_trait::async_trait;
    use valida::prelude::*;

    pub struct MinAge(pub i32);

    #[async_trait]
    impl IValidatorRuleCustomAsync<i32, std::io::Error> for MinAge {
        async fn validate(&self, value: &i32) -> Result<Option<ValidationError>, std::io::Error> {
            if *value < self.0 {
                Ok(Some(ValidationError::new("age.too_young")))
            } else {
                Ok(None)
            }
        }
    }

    // ───── Sync Rule для тесту ─────
    pub struct NoNumber;

    impl IValidatorRuleCustom<String, std::io::Error> for NoNumber {
        fn validate(&self, value: &String) -> Result<Option<ValidationError>, std::io::Error> {
            if value.chars().any(|c| c.is_ascii_digit()) {
                Ok(Some(ValidationError::new("name.has_number")))
            } else {
                Ok(None)
            }
        }
    }

    // ───── DTO для тесту custom + custom_async ─────
    #[derive(Debug)]
    struct SampleDto {
        name: String,
        age: i32,
    }

    pub struct SampleValidator;

    #[async_trait]
    impl IValidate<SampleDto, std::io::Error> for SampleValidator {
        fn rules(
            &self,
            mut builder: RulesBuilder<SampleDto, std::io::Error>,
        ) -> RulesBuilder<SampleDto, std::io::Error> {
            builder
                .field("name", |x| &x.name)
                .trimmed()
                .custom(NoNumber)
                .build();

            builder
                .field("age", |x| &x.age)
                .custom_async(MinAge(18))
                .build();

            builder
        }
    }

    #[tokio::test]
    async fn detects_custom_rules_violation() {
        let dto = SampleDto {
            name: "John99".into(), // ❌ has digit
            age: 14,               // ❌ too young
        };

        let validator = SampleValidator;
        let errors = match validator.validate(&dto).await {
            Ok(_) => panic!("Should be invalid"),
            Err(ValidatorFailure::Invalid(e)) => e,
            Err(ValidatorFailure::System(e)) => panic!("System error: {:?}", e),
        };

        // 🔧 Виправлення виклику to_json
        let json = errors.to_json_raw();

        // 🔧 Перетворення Value → String для перевірки contains
        let json_str = serde_json::to_string(&json).expect("JSON serialization failed");

        assert!(json_str.contains("name.has_number"));
        assert!(json_str.contains("age.too_young"));
    }
}