Struct async_graphql::context::ContextBase

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

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

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

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.

Examples found in repository

src/types/external/optional.rs (line 72)

    async fn resolve(
        &self,
        ctx: &ContextSelectionSet<'_>,
        field: &Positioned<Field>,
    ) -> ServerResult<Value> {
        if let Some(inner) = self {
            match OutputType::resolve(inner, ctx, field).await {
                Ok(value) => Ok(value),
                Err(err) => {
                    ctx.add_error(err);
                    Ok(Value::Null)
                }
            }
        } else {
            Ok(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.

Examples found in repository

src/context.rs (line 302)

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

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.

Examples found in repository

src/context.rs (line 306)

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

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.

Examples found in repository

src/context.rs (line 310)

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

impl<'a, T> ContextBase<'a, T> {
    #[doc(hidden)]
    pub fn with_field(
        &'a self,
        field: &'a Positioned<Field>,
    ) -> ContextBase<'a, &'a Positioned<Field>> {
        ContextBase {
            path_node: Some(QueryPathNode {
                parent: self.path_node.as_ref(),
                segment: QueryPathSegment::Name(&field.node.response_key().node),
            }),
            is_for_introspection: self.is_for_introspection,
            item: field,
            schema_env: self.schema_env,
            query_env: self.query_env,
        }
    }

    #[doc(hidden)]
    pub fn with_selection_set(
        &self,
        selection_set: &'a Positioned<SelectionSet>,
    ) -> ContextBase<'a, &'a Positioned<SelectionSet>> {
        ContextBase {
            path_node: self.path_node,
            is_for_introspection: self.is_for_introspection,
            item: selection_set,
            schema_env: self.schema_env,
            query_env: self.query_env,
        }
    }

    #[doc(hidden)]
    pub fn set_error_path(&self, error: ServerError) -> ServerError {
        if let Some(node) = self.path_node {
            let mut path = Vec::new();
            node.for_each(|current_node| {
                path.push(match current_node {
                    QueryPathSegment::Name(name) => PathSegment::Field((*name).to_string()),
                    QueryPathSegment::Index(idx) => PathSegment::Index(*idx),
                })
            });
            ServerError { path, ..error }
        } else {
            error
        }
    }

    /// Report a resolver error.
    ///
    /// When implementing `OutputType`, if an error occurs, call this function
    /// to report this error and return `Value::Null`.
    pub fn add_error(&self, error: ServerError) {
        self.query_env.errors.lock().unwrap().push(error);
    }

    /// 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<D: Any + Send + Sync>(&self) -> Result<&'a D> {
        self.data_opt::<D>().ok_or_else(|| {
            Error::new(format!(
                "Data `{}` does not exist.",
                std::any::type_name::<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_unchecked<D: Any + Send + Sync>(&self) -> &'a D {
        self.data_opt::<D>()
            .unwrap_or_else(|| panic!("Data `{}` does not exist.", std::any::type_name::<D>()))
    }

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

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

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, T: Clone> Clone for ContextBase<'a, T>

fn clone(&self) -> ContextBase<'a, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Gets the global data defined in the Context or Schema.

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

Gets the global data defined in the Context or Schema.

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.