Function async_graphql::types::connection::query

pub async fn query<Cursor, Node, ConnectionFields, EdgeFields, F, R>(
    after: Option<String>, 
    before: Option<String>, 
    first: Option<i32>, 
    last: Option<i32>, 
    f: F
) -> Result<Connection<Cursor, Node, ConnectionFields, EdgeFields>> where
    Cursor: CursorType + Send + Sync,
    <Cursor as CursorType>::Error: Display + Send + Sync + 'static,
    F: FnOnce(Option<Cursor>, Option<Cursor>, Option<usize>, Option<usize>) -> R,
    R: Future<Output = Result<Connection<Cursor, Node, ConnectionFields, EdgeFields>>>, 

Parses the parameters and executes the query.

Examples

use async_graphql::*;
use async_graphql::connection::*;

struct QueryRoot;

struct Numbers;

#[derive(SimpleObject)]
struct Diff {
    diff: i32,
}

#[Object]
impl QueryRoot {
    async fn numbers(&self,
        after: Option<String>,
        before: Option<String>,
        first: Option<i32>,
        last: Option<i32>
    ) -> Result<Connection<usize, i32, EmptyFields, Diff>> {
        query(after, before, first, last, |after, before, first, last| async move {
            let mut start = after.map(|after| after + 1).unwrap_or(0);
            let mut end = before.unwrap_or(10000);
            if let Some(first) = first {
                end = (start + first).min(end);
            }
            if let Some(last) = last {
                start = if last > end - start {
                    end
                } else {
                    end - last
                };
            }
            let mut connection = Connection::new(start > 0, end < 10000);
            connection.append(
                (start..end).into_iter().map(|n|
                    Edge::with_additional_fields(n, n as i32, Diff{ diff: (10000 - n) as i32 })),
            );
            Ok(connection)
        }).await
    }
}

tokio::runtime::Runtime::new().unwrap().block_on(async {
    let schema = Schema::new(QueryRoot, EmptyMutation, EmptySubscription);

    assert_eq!(schema.execute("{ numbers(first: 2) { edges { node diff } } }").await.into_result().unwrap().data, value!({
        "numbers": {
            "edges": [
                {"node": 0, "diff": 10000},
                {"node": 1, "diff": 9999},
            ]
        },
    }));

    assert_eq!(schema.execute("{ numbers(last: 2) { edges { node diff } } }").await.into_result().unwrap().data, value!({
        "numbers": {
            "edges": [
                {"node": 9998, "diff": 2},
                {"node": 9999, "diff": 1},
            ]
        },
    }));
});