Struct async_graphql::dynamic::ResolverContext

pub struct ResolverContext<'a> {
    pub ctx: &'a Context<'a>,
    pub args: ObjectAccessor<'a>,
    pub parent_value: &'a FieldValue<'a>,
}

Available on crate feature dynamic-schema only.

A context for resolver function

Fields

ctx: &'a Context<'a>

GraphQL context

args: ObjectAccessor<'a>

Field arguments

parent_value: &'a FieldValue<'a>

Parent value

Methods from Deref<Target = Context<'a>>

pub fn add_error(&self, error: ServerError)

Report a resolver error.

When implementing OutputType, if an error occurs, call this function to report this error and return Value::Null.

pub fn data<D: Any + Send + Sync>(&self) -> Result<&'a D>

Gets the global data defined in the Context or Schema.

If both Schema and Query have the same data type, the data in the Query is obtained.

Errors

Returns a Error if the specified type data does not exist.

pub fn data_unchecked<D: Any + Send + Sync>(&self) -> &'a D

Gets the global data defined in the Context or Schema.

Panics

It will panic if the specified data type does not exist.

pub fn data_opt<D: Any + Send + Sync>(&self) -> Option<&'a D>

Gets the global data defined in the Context or Schema or None if the specified type data does not exist.

pub fn http_header_contains(&self, key: impl AsHeaderName) -> bool

Returns whether the HTTP header key is currently set on the response

Examples

use ::http::header::ACCESS_CONTROL_ALLOW_ORIGIN;
use async_graphql::*;

struct Query;

#[Object]
impl Query {
    async fn greet(&self, ctx: &Context<'_>) -> String {
        let header_exists = ctx.http_header_contains("Access-Control-Allow-Origin");
        assert!(!header_exists);

        ctx.insert_http_header(ACCESS_CONTROL_ALLOW_ORIGIN, "*");

        let header_exists = ctx.http_header_contains("Access-Control-Allow-Origin");
        assert!(header_exists);

        String::from("Hello world")
    }
}

pub fn insert_http_header(
    &self,
    name: impl IntoHeaderName,
    value: impl TryInto<HeaderValue>
) -> Option<HeaderValue>

Sets a HTTP header to response.

If the header was not currently set on the response, then None is returned.

If the response already contained this header then the new value is associated with this key and all the previous values are removed, however only a the first previous value is returned.

See http::HeaderMap for more details on the underlying implementation

Examples

use ::http::{header::ACCESS_CONTROL_ALLOW_ORIGIN, HeaderValue};
use async_graphql::*;

struct Query;

#[Object]
impl Query {
    async fn greet(&self, ctx: &Context<'_>) -> String {
        // Headers can be inserted using the `http` constants
        let was_in_headers = ctx.insert_http_header(ACCESS_CONTROL_ALLOW_ORIGIN, "*");
        assert_eq!(was_in_headers, None);

        // They can also be inserted using &str
        let was_in_headers = ctx.insert_http_header("Custom-Header", "1234");
        assert_eq!(was_in_headers, None);

        // If multiple headers with the same key are `inserted` then the most recent
        // one overwrites the previous. If you want multiple headers for the same key, use
        // `append_http_header` for subsequent headers
        let was_in_headers = ctx.insert_http_header("Custom-Header", "Hello World");
        assert_eq!(was_in_headers, Some(HeaderValue::from_static("1234")));

        String::from("Hello world")
    }
}

pub fn append_http_header(
    &self,
    name: impl IntoHeaderName,
    value: impl TryInto<HeaderValue>
) -> bool

Sets a HTTP header to response.

If the header was not currently set on the response, then false is returned.

If the response did have this header then the new value is appended to the end of the list of values currently associated with the key, however the key is not updated (which is important for types that can be == without being identical).

See http::HeaderMap for more details on the underlying implementation

Examples

use ::http::header::SET_COOKIE;
use async_graphql::*;

struct Query;

#[Object]
impl Query {
    async fn greet(&self, ctx: &Context<'_>) -> String {
        // Insert the first instance of the header
        ctx.insert_http_header(SET_COOKIE, "Chocolate Chip");

        // Subsequent values should be appended
        let header_already_exists = ctx.append_http_header("Set-Cookie", "Macadamia");
        assert!(header_already_exists);

        String::from("Hello world")
    }
}

pub fn look_ahead(&self) -> Lookahead<'_>

Creates a uniform interface to inspect the forthcoming selections.

Examples

use async_graphql::*;

#[derive(SimpleObject)]
struct Detail {
    c: i32,
    d: i32,
}

#[derive(SimpleObject)]
struct MyObj {
    a: i32,
    b: i32,
    detail: Detail,
}

struct Query;

#[Object]
impl Query {
    async fn obj(&self, ctx: &Context<'_>) -> MyObj {
        if ctx.look_ahead().field("a").exists() {
            // This is a query like `obj { a }`
        } else if ctx.look_ahead().field("detail").field("c").exists() {
            // This is a query like `obj { detail { c } }`
        } else {
            // This query doesn't have `a`
        }
        unimplemented!()
    }
}

pub fn field(&self) -> SelectionField<'_>

Get the current field.

Examples

use async_graphql::*;

#[derive(SimpleObject)]
struct MyObj {
    a: i32,
    b: i32,
    c: i32,
}

pub struct Query;

#[Object]
impl Query {
    async fn obj(&self, ctx: &Context<'_>) -> MyObj {
        let fields = ctx
            .field()
            .selection_set()
            .map(|field| field.name())
            .collect::<Vec<_>>();
        assert_eq!(fields, vec!["a", "b", "c"]);
        MyObj { a: 1, b: 2, c: 3 }
    }
}

let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
assert!(schema.execute("{ obj { a b c }}").await.is_ok());
assert!(schema.execute("{ obj { a ... { b c } }}").await.is_ok());
assert!(schema
    .execute("{ obj { a ... BC }} fragment BC on MyObj { b c }")
    .await
    .is_ok());

Trait Implementations

impl<'a> Deref for ResolverContext<'a>

type Target = ContextBase<'a, &'a Positioned<Field>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.