Struct async_graphql::Schema

pub struct Schema<Query, Mutation, Subscription>(_);

GraphQL schema.

Cloning a schema is cheap, so it can be easily shared.

Implementations

impl<Query, Mutation, Subscription> Schema<Query, Mutation, Subscription>where
    Query: ObjectType + 'static,
    Mutation: ObjectType + 'static,
    Subscription: SubscriptionType + 'static,

pub fn build(
    query: Query,
    mutation: Mutation,
    subscription: Subscription
) -> SchemaBuilder<Query, Mutation, Subscription>

Create a schema builder

The root object for the query and Mutation needs to be specified. If there is no mutation, you can use EmptyMutation. If there is no subscription, you can use EmptySubscription.

Examples found in repository

src/schema.rs (line 406)

    pub fn new(
        query: Query,
        mutation: Mutation,
        subscription: Subscription,
    ) -> Schema<Query, Mutation, Subscription> {
        Self::build(query, mutation, subscription).finish()
    }

pub fn build_with_ignore_name_conflicts<I, T>(
    query: Query,
    mutation: Mutation,
    subscription: Subscription,
    ignore_name_conflicts: I
) -> SchemaBuilder<Query, Mutation, Subscription>where
    I: IntoIterator<Item = T>,
    T: Into<String>,

Create a schema builder and specifies a list to ignore type conflict detection.

NOTE: It is not recommended to use it unless you know what it does.

Examples found in repository

src/schema.rs (line 329)

    pub fn build(
        query: Query,
        mutation: Mutation,
        subscription: Subscription,
    ) -> SchemaBuilder<Query, Mutation, Subscription> {
        Self::build_with_ignore_name_conflicts(query, mutation, subscription, [] as [&str; 0])
    }

pub fn new(
    query: Query,
    mutation: Mutation,
    subscription: Subscription
) -> Schema<Query, Mutation, Subscription>

Create a schema

Examples found in repository

src/schema.rs (lines 305-309)

    fn default() -> Self {
        Schema::new(
            Query::default(),
            Mutation::default(),
            Subscription::default(),
        )
    }

pub fn sdl(&self) -> String

Returns SDL(Schema Definition Language) of this schema.

pub fn sdl_with_options(&self, options: SDLExportOptions) -> String

Returns SDL(Schema Definition Language) of this schema with options.

pub fn names(&self) -> Vec<String>

Get all names in this schema

Maybe you want to serialize a custom binary protocol. In order to minimize message size, a dictionary is usually used to compress type names, field names, directive names, and parameter names. This function gets all the names, so you can create this dictionary.

pub async fn execute(&self, request: impl Into<Request>) -> Response

Execute a GraphQL query.

Examples found in repository

src/schema.rs (line 522)

    pub async fn execute_batch(&self, batch_request: BatchRequest) -> BatchResponse {
        match batch_request {
            BatchRequest::Single(request) => BatchResponse::Single(self.execute(request).await),
            BatchRequest::Batch(requests) => BatchResponse::Batch(
                futures_util::stream::iter(requests.into_iter())
                    .then(|request| self.execute(request))
                    .collect()
                    .await,
            ),
        }
    }

    /// Execute a GraphQL subscription with session data.
    pub fn execute_stream_with_session_data(
        &self,
        request: impl Into<Request>,
        session_data: Arc<Data>,
    ) -> impl Stream<Item = Response> + Send + Unpin {
        let schema = self.clone();
        let request = request.into();
        let extensions = self.create_extensions(session_data.clone());

        let stream = futures_util::stream::StreamExt::boxed({
            let extensions = extensions.clone();
            let env = self.0.env.clone();
            async_stream::stream! {
                let (env, cache_control) = match prepare_request(
                        extensions, request, session_data, &env.registry,
                        schema.0.validation_mode, schema.0.recursive_depth, schema.0.complexity, schema.0.depth
                ).await {
                    Ok(res) => res,
                    Err(errors) => {
                        yield Response::from_errors(errors);
                        return;
                    }
                };

                if env.operation.node.ty != OperationType::Subscription {
                    yield schema.execute_once(env).await.cache_control(cache_control);
                    return;
                }

                let ctx = env.create_context(
                    &schema.0.env,
                    None,
                    &env.operation.node.selection_set,
                );

                let mut streams = Vec::new();
                let collect_result = if schema.0.env.registry.introspection_mode
                    == IntrospectionMode::IntrospectionOnly
                    || env.introspection_mode == IntrospectionMode::IntrospectionOnly
                {
                    collect_subscription_streams(&ctx, &EmptySubscription, &mut streams)
                } else {
                    collect_subscription_streams(&ctx, &schema.0.subscription, &mut streams)
                };
                if let Err(err) = collect_result {
                    yield Response::from_errors(vec![err]);
                }

                let mut stream = stream::select_all(streams);
                while let Some(resp) = stream.next().await {
                    yield resp;
                }
            }
        });
        extensions.subscribe(stream)
    }

    /// Execute a GraphQL subscription.
    pub fn execute_stream(
        &self,
        request: impl Into<Request>,
    ) -> impl Stream<Item = Response> + Send + Unpin {
        self.execute_stream_with_session_data(request, Default::default())
    }
}

#[async_trait::async_trait]
impl<Query, Mutation, Subscription> Executor for Schema<Query, Mutation, Subscription>
where
    Query: ObjectType + 'static,
    Mutation: ObjectType + 'static,
    Subscription: SubscriptionType + 'static,
{
    async fn execute(&self, request: Request) -> Response {
        Schema::execute(self, request).await
    }

pub async fn execute_batch(&self, batch_request: BatchRequest) -> BatchResponse

Execute a GraphQL batch query.

pub fn execute_stream_with_session_data(
    &self,
    request: impl Into<Request>,
    session_data: Arc<Data>
) -> impl Stream<Item = Response> + Send + Unpin

Execute a GraphQL subscription with session data.

Examples found in repository

src/schema.rs (line 595)

    pub fn execute_stream(
        &self,
        request: impl Into<Request>,
    ) -> impl Stream<Item = Response> + Send + Unpin {
        self.execute_stream_with_session_data(request, Default::default())
    }
}

#[async_trait::async_trait]
impl<Query, Mutation, Subscription> Executor for Schema<Query, Mutation, Subscription>
where
    Query: ObjectType + 'static,
    Mutation: ObjectType + 'static,
    Subscription: SubscriptionType + 'static,
{
    async fn execute(&self, request: Request) -> Response {
        Schema::execute(self, request).await
    }

    fn execute_stream(
        &self,
        request: Request,
        session_data: Option<Arc<Data>>,
    ) -> BoxStream<'static, Response> {
        Schema::execute_stream_with_session_data(&self, request, session_data.unwrap_or_default())
            .boxed()
    }

pub fn execute_stream(
    &self,
    request: impl Into<Request>
) -> impl Stream<Item = Response> + Send + Unpin

Execute a GraphQL subscription.

Trait Implementations

impl<Query, Mutation, Subscription> Clone for Schema<Query, Mutation, Subscription>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Query, Mutation, Subscription> Default for Schema<Query, Mutation, Subscription>where
    Query: Default + ObjectType + 'static,
    Mutation: Default + ObjectType + 'static,
    Subscription: Default + SubscriptionType + 'static,

fn default() -> Self

Returns the “default value” for a type.

impl<Query, Mutation, Subscription> Executor for Schema<Query, Mutation, Subscription>where
    Query: ObjectType + 'static,
    Mutation: ObjectType + 'static,
    Subscription: SubscriptionType + 'static,

fn execute<'life0, 'async_trait>(
    &'life0 self,
    request: Request
) -> Pin<Box<dyn Future<Output = Response> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Execute a GraphQL query.

fn execute_stream(
    &self,
    request: Request,
    session_data: Option<Arc<Data>>
) -> BoxStream<'static, Response>

Execute a GraphQL subscription with session data.

fn execute_batch<'life0, 'async_trait>(
    &'life0 self,
    batch_request: BatchRequest
) -> Pin<Box<dyn Future<Output = BatchResponse> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Execute a GraphQL batch query.