cynic 3.13.2

A code first GraphQL client for 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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

/// The response to a GraphQl operation
#[derive(Debug, Clone)]
pub struct GraphQlResponse<T, ErrorExtensions = serde::de::IgnoredAny> {
    /// The operation data (if the operation was successful)
    pub data: Option<T>,

    /// Any errors that occurred as part of this operation
    pub errors: Option<Vec<GraphQlError<ErrorExtensions>>>,
}

/// A model describing an error which has taken place during execution.
#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, thiserror::Error)]
#[error("{message}")]
pub struct GraphQlError<Extensions = serde::de::IgnoredAny> {
    /// A description of the error which has taken place.
    pub message: String,
    /// Optional description of the locations where the errors have taken place.
    pub locations: Option<Vec<GraphQlErrorLocation>>,
    /// Optional path to the response field which experienced the associated error.
    pub path: Option<Vec<GraphQlErrorPathSegment>>,
    /// Optional arbitrary extra data describing the error in more detail.
    pub extensions: Option<Extensions>,
}

impl<ErrorExtensions> GraphQlError<ErrorExtensions> {
    /// Construct a new instance.
    pub fn new(
        message: String,
        locations: Option<Vec<GraphQlErrorLocation>>,
        path: Option<Vec<GraphQlErrorPathSegment>>,
        extensions: Option<ErrorExtensions>,
    ) -> Self {
        GraphQlError {
            message,
            locations,
            path,
            extensions,
        }
    }
}

/// A line and column offset describing the location of an error within a GraphQL document.
#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize)]
pub struct GraphQlErrorLocation {
    /// The line at which the associated error begins.
    pub line: i32,
    /// The column of the line at which the associated error begins.
    pub column: i32,
}

/// A segment of a GraphQL error path.
#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize)]
#[serde(untagged)]
pub enum GraphQlErrorPathSegment {
    /// A path segment representing a field by name.
    Field(String),
    /// A path segment representing an index offset, zero-based.
    Index(i32),
}

impl<'de, T, ErrorExtensions> serde::Deserialize<'de> for GraphQlResponse<T, ErrorExtensions>
where
    T: serde::Deserialize<'de>,
    ErrorExtensions: serde::Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        use serde::de::Error;

        #[derive(serde::Deserialize)]
        struct ResponseDeser<T, ErrorExtensions> {
            /// The operation data (if the operation was successful)
            data: Option<T>,

            /// Any errors that occurred as part of this operation
            errors: Option<Vec<GraphQlError<ErrorExtensions>>>,
        }

        let ResponseDeser { data, errors } = ResponseDeser::deserialize(deserializer)?;

        if data.is_none() && errors.is_none() {
            return Err(D::Error::custom(
                "Either data or errors must be present in a GraphQL response",
            ));
        }

        Ok(GraphQlResponse { data, errors })
    }
}

#[cfg(test)]
mod tests {
    use serde_json::json;

    use super::*;

    #[test]
    fn test_default_graphql_response_ignores_extensions() {
        let response = json!({
            "data": null,
            "errors": [{
                "message": "hello",
                "locations": null,
                "path": null,
                "extensions": {"some": "string"}
            }]
        });
        insta::assert_debug_snapshot!(serde_json::from_value::<GraphQlResponse<()>>(response).unwrap(), @r###"
        GraphQlResponse {
            data: None,
            errors: Some(
                [
                    GraphQlError {
                        message: "hello",
                        locations: None,
                        path: None,
                        extensions: Some(
                            IgnoredAny,
                        ),
                    },
                ],
            ),
        }
        "###);
    }

    #[test]
    fn test_graphql_response_fails_on_completely_invalid_response() {
        let response = json!({
            "message": "This endpoint requires you to be authenticated.",
        });
        serde_json::from_value::<GraphQlResponse<()>>(response).unwrap_err();
    }
}