Struct juniper_rocket::GraphQLRequest

pub struct GraphQLRequest<S = DefaultScalarValue>(/* private fields */)
where
    S: ScalarValue;

Simple wrapper around an incoming GraphQL request.

See the http module for more information. This type can be constructed automatically from both GET and POST routes, as implements FromForm and FromData traits.

Example

use juniper::{
    tests::fixtures::starwars::schema::{Database, Query},
    EmptyMutation, EmptySubscription, RootNode,
};
use rocket::{routes, State};

type Schema = RootNode<'static, Query, EmptyMutation<Database>, EmptySubscription<Database>>;

// GET request accepts query parameters like these:
// ?query=<urlencoded-graphql-query-string>
// &operationName=<optional-name>
// &variables=<optional-json-encoded-variables>
// See details here: https://graphql.org/learn/serving-over-http#get-request
#[rocket::get("/graphql?<request..>")]
async fn get_graphql_handler(
    db: &State<Database>,
    request: juniper_rocket::GraphQLRequest,
    schema: &State<Schema>,
) -> juniper_rocket::GraphQLResponse {
    request.execute(schema, db).await
}

#[rocket::post("/graphql", data = "<request>")]
async fn post_graphql_handler(
    db: &State<Database>,
    request: juniper_rocket::GraphQLRequest,
    schema: &State<Schema>,
) -> juniper_rocket::GraphQLResponse {
    request.execute(schema, db).await
}

let rocket = rocket::build()
    .manage(Database::new())
    .manage(Schema::new(Query, EmptyMutation::new(), EmptySubscription::new()))
    .mount("/", routes![get_graphql_handler, post_graphql_handler]);

Implementations

impl<S> GraphQLRequest<S>

where S: ScalarValue,

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

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

Synchronously execute an incoming GraphQL query.

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

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

Asynchronously execute an incoming GraphQL query.

pub fn operation_names(&self) -> Vec<Option<&str>>

Returns the operation names associated with this request.

For batch requests there will be multiple names.

Trait Implementations

impl<S: ScalarValue> AsMut<GraphQLBatchRequest<S>> for GraphQLRequest<S>

fn as_mut(&mut self) -> &mut GraphQLBatchRequest<S>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<S: ScalarValue> AsRef<GraphQLBatchRequest<S>> for GraphQLRequest<S>

fn as_ref(&self) -> &GraphQLBatchRequest<S>

Converts this type into a shared reference of the (usually inferred) input type.

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<'r, S> FromData<'r> for GraphQLRequest<S>

where S: ScalarValue,

type Error = String

The associated error to be returned when the guard fails.

fn from_data<'life0, 'async_trait>( req: &'r Request<'life0>, data: Data<'r> ) -> Pin<Box<dyn Future<Output = Outcome<'r, Self, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait,

Asynchronously validates, parses, and converts an instance of Self from the incoming request body data.

impl<'f, S> FromForm<'f> for GraphQLRequest<S>

where S: ScalarValue + Send,

type Context = GraphQLContext<'f, S>

The form guard’s parsing context.

fn init(opts: Options) -> Self::Context

Initializes and returns the parsing context for Self.

fn push_value(ctx: &mut Self::Context, field: ValueField<'f>)

Processes the value field field.

fn push_data<'life0, 'life1, 'async_trait>( ctx: &'life0 mut Self::Context, field: DataField<'f, 'life1> ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'f: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Processes the data field field.

fn finalize(ctx: Self::Context) -> Result<'f, Self>

Finalizes parsing. Returns the parsed value when successful or collection of Errors otherwise.

fn push_error(_ctxt: &mut Self::Context, _error: Error<'r>)

Processes the external form or field error _error.

fn default(opts: Options) -> Option<Self>

Returns a default value, if any, to use when a value is desired and parsing fails.

impl<S> PartialEq for GraphQLRequest<S>

where S: ScalarValue + PartialEq,

fn eq(&self, other: &GraphQLRequest<S>) -> 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<S> StructuralPartialEq for GraphQLRequest<S>

where S: ScalarValue,