Struct async_graphql::context::ContextBase

source ·

pub struct ContextBase<'a, T> {
    pub path_node: Option<QueryPathNode<'a>>,
    /* private fields */
}

Expand description

Query context.

This type is not stable and should not be used directly.

Fields§

§path_node: Option<QueryPathNode<'a>>

The current path node being resolved.

Implementations§

source §

impl<'a, T> ContextBase<'a, T>

source

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.

source

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.

source

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.

source

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.

source

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")
    }
}

source

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")
    }
}

source

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")
    }
}

source §

impl<'a> ContextBase<'a, &'a Positioned<Field>>

source

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!()
    }
}

source

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());