vld 0.3.0

Type-safe runtime validation library for Rust, inspired by Zod
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

use serde_json::Value;

use crate::error::VldError;
use crate::schema::VldSchema;

/// Intersection of two schemas: input must satisfy both.
///
/// Both schemas are run on the same input. If both succeed, the output of the
/// **first** schema is returned. If either fails, all errors are merged.
///
/// Created via [`vld::intersection()`](crate::intersection).
///
/// # Example
/// ```ignore
/// let schema = vld::intersection(
///     vld::string().min(3),
///     vld::string().email(),
/// );
/// ```
pub struct ZIntersection<A: VldSchema, B: VldSchema> {
    first: A,
    second: B,
}

impl<A: VldSchema, B: VldSchema> ZIntersection<A, B> {
    pub fn new(first: A, second: B) -> Self {
        Self { first, second }
    }

    /// Access the first schema.
    pub fn schema_a(&self) -> &A {
        &self.first
    }
    /// Access the second schema.
    pub fn schema_b(&self) -> &B {
        &self.second
    }
}

impl<A: VldSchema, B: VldSchema> VldSchema for ZIntersection<A, B> {
    type Output = A::Output;

    fn parse_value(&self, value: &Value) -> Result<A::Output, VldError> {
        let mut errors = VldError::new();

        let first_result = match self.first.parse_value(value) {
            Ok(v) => Some(v),
            Err(e) => {
                errors = errors.merge(e);
                None
            }
        };

        if let Err(e) = self.second.parse_value(value) {
            errors = errors.merge(e);
        }

        if errors.is_empty() {
            Ok(first_result.unwrap())
        } else {
            Err(errors)
        }
    }
}