Struct GraphQLRequest 

pub struct GraphQLRequest<S = DefaultScalarValue>
where
    S: ScalarValue,
{
    pub query: String,
    pub operation_name: Option<String>,
    pub variables: Option<InputValue<S>>,
}

The expected structure of the decoded JSON document for either POST or GET requests.

For POST, you can use Serde to deserialize the incoming JSON data directly into this struct - it derives Deserialize for exactly this reason.

For GET, you will need to parse the query string and extract “query”, “operationName”, and “variables” manually.

Fields

query: String

GraphQL query representing this request.

operation_name: Option<String>

Optional name of the operation associated with this request.

variables: Option<InputValue<S>>

Optional variables to execute the GraphQL operation with.

Implementations

impl<S> GraphQLRequest<S>

where S: ScalarValue,

pub fn operation_name(&self) -> Option<&str>

👎Deprecated since 0.16.0: Use the direct field access instead.

Returns the operation_name associated with this request.

pub fn variables(&self) -> Variables<S>

Returns operation Variables defined withing this request.

pub fn new( query: String, operation_name: Option<String>, variables: Option<InputValue<S>>, ) -> Self

Construct a new GraphQL request from parts

pub fn execute_sync<QueryT, MutationT, SubscriptionT>( &self, root_node: &RootNode<QueryT, MutationT, SubscriptionT, S>, context: &QueryT::Context, ) -> GraphQLResponse<S>

where S: ScalarValue, QueryT: GraphQLType<S>, MutationT: GraphQLType<S, Context = QueryT::Context>, SubscriptionT: GraphQLType<S, Context = QueryT::Context>,

Execute a GraphQL request synchronously using the specified schema and context

This is a simple wrapper around the execute_sync function exposed at the top level of this crate.

pub async fn execute<'a, QueryT, MutationT, SubscriptionT>( &'a self, root_node: &'a RootNode<QueryT, MutationT, SubscriptionT, S>, context: &'a QueryT::Context, ) -> GraphQLResponse<S>

where QueryT: GraphQLTypeAsync<S>, QueryT::TypeInfo: Sync, QueryT::Context: Sync, MutationT: GraphQLTypeAsync<S, Context = QueryT::Context>, MutationT::TypeInfo: Sync, SubscriptionT: GraphQLType<S, Context = QueryT::Context> + Sync, SubscriptionT::TypeInfo: Sync, S: ScalarValue + Send + Sync,

Execute a GraphQL request using the specified schema and context

This is a simple wrapper around the execute function exposed at the top level of this crate.

Trait Implementations

impl<S> Clone for GraphQLRequest<S>

where S: ScalarValue + Clone,

fn clone(&self) -> GraphQLRequest<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> Debug for GraphQLRequest<S>

where S: ScalarValue + Debug,

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

Formats the value using the given formatter.

impl<'de, S> Deserialize<'de> for GraphQLRequest<S>

where S: ScalarValue, InputValue<S>: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> PartialEq for GraphQLRequest<S>

where S: ScalarValue + PartialEq,

fn eq(&self, other: &GraphQLRequest<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<S> Serialize for GraphQLRequest<S>

where S: ScalarValue, InputValue<S>: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S> StructuralPartialEq for GraphQLRequest<S>

where S: ScalarValue,