Struct async_graphql::context::ContextBase

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

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 data<D: Any + Send + Sync>(&self) -> Result<&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) -> &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<&D>

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

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<'a>

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

async_std::task::block_on(async move {
    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>

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

Returns a copy of the value.

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

Performs copy-assignment from source.