Struct graphql_client::Response

pub struct Response<Data> {
    pub data: Option<Data>,
    pub errors: Option<Vec<Error>>,
    pub extensions: Option<HashMap<String, Value>>,
}

The generic shape taken by the responses of GraphQL APIs.

This will generally be used with the ResponseData struct from a derived module.

Spec

use graphql_client::Response;

let body: Response<ResponseData> = serde_json::from_value(json!({
    "data": {
        "users": [{"id": 13}],
        "dogs": [{"name": "Strelka"}],
    },
    "errors": [],
}))?;

let expected: Response<ResponseData> = Response {
    data: Some(ResponseData {
        users: vec![User { id: 13 }],
        dogs: vec![Dog { name: "Strelka".to_owned() }],
    }),
    errors: Some(vec![]),
    extensions: None,
};

assert_eq!(body, expected);

Fields

data: Option<Data>

The absent, partial or complete response data.

errors: Option<Vec<Error>>

The top-level errors returned by the server.

extensions: Option<HashMap<String, Value>>

Additional extensions. Their exact format is defined by the server. See GraphQL Response Specification

Trait Implementations

impl<Data: Debug> Debug for Response<Data>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, Data> Deserialize<'de> for Response<Data>

where Data: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Data: PartialEq> PartialEq for Response<Data>

fn eq(&self, other: &Response<Data>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Data> Serialize for Response<Data>

where Data: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Data: Eq> Eq for Response<Data>

impl<Data> StructuralPartialEq for Response<Data>