async-graphql 1.7.3

The GraphQL server library implemented by rust
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

mod int_validators;
mod list_validators;
mod string_validators;

use graphql_parser::schema::Value;

pub use int_validators::{IntGreaterThan, IntLessThan, IntNonZero, IntRange};
pub use list_validators::{ListMaxLength, ListMinLength};
pub use string_validators::{Email, StringMaxLength, StringMinLength, MAC};

/// Input value validator
///
/// You can create your own input value validator by implementing this trait.
///
/// ```no_run
/// use async_graphql::*;
/// use async_graphql::validators::{Email, MAC, IntRange};
///
/// struct QueryRoot;
///
/// #[Object]
/// impl QueryRoot {
///     // Input is email address
///     #[field]
///     async fn value1(&self, #[arg(validator(Email))] email: String) -> i32 {
///         unimplemented!()
///     }
///
///     // Input is email or MAC address
///     #[field]
///     async fn value2(&self, #[arg(validator(or(Email, MAC(colon = false))))] email_or_mac: String) -> i32 {
///         unimplemented!()
///     }
///
///     // Input is integer between 100 and 200
///     #[field]
///     async fn value3(&self, #[arg(validator(IntRange(min = 100, max = 200)))] value: i32) -> i32 {
///         unimplemented!()
///     }
/// }
/// ```
pub trait InputValueValidator
where
    Self: Sync + Send,
{
    /// Check value is valid, returns the reason for the error if it fails, otherwise None.
    ///
    /// If the input type is different from the required type, return None directly, and other validators will find this error.
    fn is_valid(&self, value: &Value) -> Option<String>;
}

/// Merge the two validators and return None only if both validators are successful.
#[doc(hidden)]
pub fn and<A, B>(a: A, b: B) -> And<A, B>
where
    A: InputValueValidator,
    B: InputValueValidator,
{
    And(a, b)
}

/// Merge two validators, and return None when either validator verifies successfully.
#[doc(hidden)]
pub fn or<A, B>(a: A, b: B) -> Or<A, B>
where
    A: InputValueValidator,
    B: InputValueValidator,
{
    Or(a, b)
}

#[doc(hidden)]
pub struct And<A, B>(A, B);

impl<A, B> InputValueValidator for And<A, B>
where
    A: InputValueValidator,
    B: InputValueValidator,
{
    fn is_valid(&self, value: &Value) -> Option<String> {
        self.0.is_valid(value).and(self.1.is_valid(value))
    }
}

#[doc(hidden)]
pub struct Or<A, B>(A, B);

impl<A, B> InputValueValidator for Or<A, B>
where
    A: InputValueValidator,
    B: InputValueValidator,
{
    fn is_valid(&self, value: &Value) -> Option<String> {
        self.0.is_valid(value).or_else(|| self.1.is_valid(value))
    }
}