Struct async_graphql::ServerError

pub struct ServerError {
    pub message: String,
    pub source: Option<Arc<dyn Any + Send + Sync>>,
    pub locations: Vec<Pos>,
    pub path: Vec<PathSegment>,
    pub extensions: Option<ErrorExtensionValues>,
}

An error in a GraphQL server.

Fields

message: String

An explanatory message of the error.

source: Option<Arc<dyn Any + Send + Sync>>

The source of the error.

locations: Vec<Pos>

Where the error occurred.

path: Vec<PathSegment>

If the error occurred in a resolver, the path to the error.

extensions: Option<ErrorExtensionValues>

Extensions to the error.

Implementations

impl ServerError

pub fn new(message: impl Into<String>, pos: Option<Pos>) -> Self

Create a new server error with the message.

Examples found in repository

src/error.rs (line 237)

    pub fn into_server_error(self, pos: Pos) -> ServerError {
        let mut err = ServerError::new(self.message, Some(pos));
        err.extensions = self.extensions;
        err
    }

src/dynamic/schema.rs (line 252)

    fn query_root(&self) -> ServerResult<&Object> {
        self.0
            .types
            .get(&self.0.env.registry.query_type)
            .and_then(Type::as_object)
            .ok_or_else(|| ServerError::new("Query root not found", None))
    }

    fn mutation_root(&self) -> ServerResult<&Object> {
        self.0
            .env
            .registry
            .mutation_type
            .as_ref()
            .and_then(|mutation_name| self.0.types.get(mutation_name))
            .and_then(Type::as_object)
            .ok_or_else(|| ServerError::new("Mutation root not found", None))
    }

    fn subscription_root(&self) -> ServerResult<&Subscription> {
        self.0
            .env
            .registry
            .subscription_type
            .as_ref()
            .and_then(|subscription_name| self.0.types.get(subscription_name))
            .and_then(Type::as_subscription)
            .ok_or_else(|| ServerError::new("Subscription root not found", None))
    }

    /// Returns SDL(Schema Definition Language) of this schema.
    pub fn sdl(&self) -> String {
        self.0.env.registry.export_sdl(Default::default())
    }

    /// Returns SDL(Schema Definition Language) of this schema with options.
    pub fn sdl_with_options(&self, options: SDLExportOptions) -> String {
        self.0.env.registry.export_sdl(options)
    }

    async fn execute_once(&self, env: QueryEnv, root_value: &FieldValue<'static>) -> Response {
        // execute
        let ctx = env.create_context(&self.0.env, None, &env.operation.node.selection_set);
        let res = match &env.operation.node.ty {
            OperationType::Query => {
                async move { self.query_root() }
                    .and_then(|query_root| {
                        resolve_container(self, query_root, &ctx, root_value, false)
                    })
                    .await
            }
            OperationType::Mutation => {
                async move { self.mutation_root() }
                    .and_then(|query_root| {
                        resolve_container(self, query_root, &ctx, root_value, true)
                    })
                    .await
            }
            OperationType::Subscription => Err(ServerError::new(
                "Subscriptions are not supported on this transport.",
                None,
            )),
        };

        let mut resp = match res {
            Ok(value) => Response::new(value.unwrap_or_default()),
            Err(err) => Response::from_errors(vec![err]),
        }
        .http_headers(std::mem::take(&mut *env.http_headers.lock().unwrap()));

        resp.errors
            .extend(std::mem::take(&mut *env.errors.lock().unwrap()));
        resp
    }

src/types/empty_mutation.rs (lines 72-75)

    async fn resolve(
        &self,
        _ctx: &ContextSelectionSet<'_>,
        _field: &Positioned<Field>,
    ) -> ServerResult<Value> {
        Err(ServerError::new(
            "Schema is not configured for mutations.",
            None,
        ))
    }

src/types/empty_subscription.rs (line 48)

    fn create_field_stream<'a>(
        &'a self,
        _ctx: &'a Context<'_>,
    ) -> Option<Pin<Box<dyn Stream<Item = Response> + Send + 'a>>>
    where
        Self: Send + Sync + 'static + Sized,
    {
        Some(Box::pin(stream::once(async move {
            let err = ServerError::new("Schema is not configured for subscription.", None);
            Response::from_errors(vec![err])
        })))
    }

src/context.rs (line 566)

    fn var_value(&self, name: &str, pos: Pos) -> ServerResult<Value> {
        self.query_env
            .operation
            .node
            .variable_definitions
            .iter()
            .find(|def| def.node.name.node == name)
            .and_then(|def| {
                self.query_env
                    .variables
                    .get(&def.node.name.node)
                    .or_else(|| def.node.default_value())
            })
            .cloned()
            .ok_or_else(|| {
                ServerError::new(format!("Variable {} is not defined.", name), Some(pos))
            })
    }

src/schema.rs (lines 464-467)

    async fn execute_once(&self, env: QueryEnv) -> Response {
        // execute
        let ctx = ContextBase {
            path_node: None,
            is_for_introspection: false,
            item: &env.operation.node.selection_set,
            schema_env: &self.0.env,
            query_env: &env,
        };

        let res = match &env.operation.node.ty {
            OperationType::Query => resolve_container(&ctx, &self.0.query).await,
            OperationType::Mutation => {
                if self.0.env.registry.introspection_mode == IntrospectionMode::IntrospectionOnly
                    || env.introspection_mode == IntrospectionMode::IntrospectionOnly
                {
                    resolve_container_serial(&ctx, &EmptyMutation).await
                } else {
                    resolve_container_serial(&ctx, &self.0.mutation).await
                }
            }
            OperationType::Subscription => Err(ServerError::new(
                "Subscriptions are not supported on this transport.",
                None,
            )),
        };

        let mut resp = match res {
            Ok(value) => Response::new(value),
            Err(err) => Response::from_errors(vec![err]),
        }
        .http_headers(std::mem::take(&mut *env.http_headers.lock().unwrap()));

        resp.errors
            .extend(std::mem::take(&mut *env.errors.lock().unwrap()));
        resp
    }

    /// Execute a GraphQL query.
    pub async fn execute(&self, request: impl Into<Request>) -> Response {
        let request = request.into();
        let extensions = self.create_extensions(Default::default());
        let request_fut = {
            let extensions = extensions.clone();
            async move {
                match prepare_request(
                    extensions,
                    request,
                    Default::default(),
                    &self.0.env.registry,
                    self.0.validation_mode,
                    self.0.recursive_depth,
                    self.0.complexity,
                    self.0.depth,
                )
                .await
                {
                    Ok((env, cache_control)) => {
                        let fut = async {
                            self.execute_once(env.clone())
                                .await
                                .cache_control(cache_control)
                        };
                        futures_util::pin_mut!(fut);
                        env.extensions
                            .execute(env.operation_name.as_deref(), &mut fut)
                            .await
                    }
                    Err(errors) => Response::from_errors(errors),
                }
            }
        };
        futures_util::pin_mut!(request_fut);
        extensions.request(&mut request_fut).await
    }

    /// Execute a GraphQL batch query.
    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
    }

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

fn check_recursive_depth(doc: &ExecutableDocument, max_depth: usize) -> ServerResult<()> {
    fn check_selection_set(
        doc: &ExecutableDocument,
        selection_set: &Positioned<SelectionSet>,
        current_depth: usize,
        max_depth: usize,
    ) -> ServerResult<()> {
        if current_depth > max_depth {
            return Err(ServerError::new(
                format!(
                    "The recursion depth of the query cannot be greater than `{}`",
                    max_depth
                ),
                Some(selection_set.pos),
            ));
        }

        for selection in &selection_set.node.items {
            match &selection.node {
                Selection::Field(field) => {
                    if !field.node.selection_set.node.items.is_empty() {
                        check_selection_set(
                            doc,
                            &field.node.selection_set,
                            current_depth + 1,
                            max_depth,
                        )?;
                    }
                }
                Selection::FragmentSpread(fragment_spread) => {
                    if let Some(fragment) =
                        doc.fragments.get(&fragment_spread.node.fragment_name.node)
                    {
                        check_selection_set(
                            doc,
                            &fragment.node.selection_set,
                            current_depth + 1,
                            max_depth,
                        )?;
                    }
                }
                Selection::InlineFragment(inline_fragment) => {
                    check_selection_set(
                        doc,
                        &inline_fragment.node.selection_set,
                        current_depth + 1,
                        max_depth,
                    )?;
                }
            }
        }

        Ok(())
    }

    for (_, operation) in doc.operations.iter() {
        check_selection_set(doc, &operation.node.selection_set, 0, max_depth)?;
    }

    Ok(())
}

fn remove_skipped_selection(selection_set: &mut SelectionSet, variables: &Variables) {
    fn is_skipped(directives: &[Positioned<Directive>], variables: &Variables) -> bool {
        for directive in directives {
            let include = match &*directive.node.name.node {
                "skip" => false,
                "include" => true,
                _ => continue,
            };

            if let Some(condition_input) = directive.node.get_argument("if") {
                let value = condition_input
                    .node
                    .clone()
                    .into_const_with(|name| variables.get(&name).cloned().ok_or(()))
                    .unwrap_or_default();
                let value: bool = InputType::parse(Some(value)).unwrap_or_default();
                if include != value {
                    return true;
                }
            }
        }

        false
    }

    selection_set
        .items
        .retain(|selection| !is_skipped(selection.node.directives(), variables));

    for selection in &mut selection_set.items {
        selection.node.directives_mut().retain(|directive| {
            directive.node.name.node != "skip" && directive.node.name.node != "include"
        });
    }

    for selection in &mut selection_set.items {
        match &mut selection.node {
            Selection::Field(field) => {
                remove_skipped_selection(&mut field.node.selection_set.node, variables);
            }
            Selection::FragmentSpread(_) => {}
            Selection::InlineFragment(inline_fragment) => {
                remove_skipped_selection(&mut inline_fragment.node.selection_set.node, variables);
            }
        }
    }
}

#[allow(clippy::too_many_arguments)]
pub(crate) async fn prepare_request(
    mut extensions: Extensions,
    request: Request,
    session_data: Arc<Data>,
    registry: &Registry,
    validation_mode: ValidationMode,
    recursive_depth: usize,
    complexity: Option<usize>,
    depth: Option<usize>,
) -> Result<(QueryEnv, CacheControl), Vec<ServerError>> {
    let mut request = request;
    let query_data = Arc::new(std::mem::take(&mut request.data));
    extensions.attach_query_data(query_data.clone());

    let mut request = extensions.prepare_request(request).await?;
    let mut document = {
        let query = &request.query;
        let parsed_doc = request.parsed_query.take();
        let fut_parse = async move {
            let doc = match parsed_doc {
                Some(parsed_doc) => parsed_doc,
                None => parse_query(query)?,
            };
            check_recursive_depth(&doc, recursive_depth)?;
            Ok(doc)
        };
        futures_util::pin_mut!(fut_parse);
        extensions
            .parse_query(query, &request.variables, &mut fut_parse)
            .await?
    };

    // check rules
    let validation_result = {
        let validation_fut = async {
            check_rules(
                registry,
                &document,
                Some(&request.variables),
                validation_mode,
            )
        };
        futures_util::pin_mut!(validation_fut);
        extensions.validation(&mut validation_fut).await?
    };

    // check limit
    if let Some(limit_complexity) = complexity {
        if validation_result.complexity > limit_complexity {
            return Err(vec![ServerError::new("Query is too complex.", None)]);
        }
    }

    if let Some(limit_depth) = depth {
        if validation_result.depth > limit_depth {
            return Err(vec![ServerError::new("Query is nested too deep.", None)]);
        }
    }

    let operation = if let Some(operation_name) = &request.operation_name {
        match document.operations {
            DocumentOperations::Single(_) => None,
            DocumentOperations::Multiple(mut operations) => operations
                .remove(operation_name.as_str())
                .map(|operation| (Some(operation_name.clone()), operation)),
        }
        .ok_or_else(|| {
            ServerError::new(
                format!(r#"Unknown operation named "{}""#, operation_name),
                None,
            )
        })
    } else {
        match document.operations {
            DocumentOperations::Single(operation) => Ok((None, operation)),
            DocumentOperations::Multiple(map) if map.len() == 1 => {
                let (operation_name, operation) = map.into_iter().next().unwrap();
                Ok((Some(operation_name.to_string()), operation))
            }
            DocumentOperations::Multiple(_) => Err(ServerError::new(
                "Operation name required in request.",
                None,
            )),
        }
    };

    let (operation_name, mut operation) = operation.map_err(|err| vec![err])?;

    // remove skipped fields
    for fragment in document.fragments.values_mut() {
        remove_skipped_selection(&mut fragment.node.selection_set.node, &request.variables);
    }
    remove_skipped_selection(&mut operation.node.selection_set.node, &request.variables);

    let env = QueryEnvInner {
        extensions,
        variables: request.variables,
        operation_name,
        operation,
        fragments: document.fragments,
        uploads: request.uploads,
        session_data,
        ctx_data: query_data,
        extension_data: Arc::new(request.data),
        http_headers: Default::default(),
        introspection_mode: request.introspection_mode,
        errors: Default::default(),
    };
    Ok((QueryEnv::new(env), validation_result.cache_control))
}

Additional examples can be found in:

• src/validation/visitor.rs
• src/extensions/apollo_persisted_queries.rs
• src/types/query_root.rs
• src/resolver_utils/container.rs
• src/dynamic/resolve.rs

pub fn source<T: Any + Send + Sync>(&self) -> Option<&T>

Get the source of the error.

Examples

use std::io::ErrorKind;

use async_graphql::*;

struct Query;

#[Object]
impl Query {
    async fn value(&self) -> Result<i32> {
        Err(Error::new_with_source(std::io::Error::new(
            ErrorKind::Other,
            "my error",
        )))
    }
}

let schema = Schema::new(Query, EmptyMutation, EmptySubscription);

let err = schema
    .execute("{ value }")
    .await
    .into_result()
    .unwrap_err()
    .remove(0);
assert!(err.source::<std::io::Error>().is_some());

Trait Implementations

impl Clone for ServerError

fn clone(&self) -> ServerError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ServerError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ServerError

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ServerError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Error> for ServerError

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<ServerError> for Vec<ServerError>

fn from(single: ServerError) -> Self

Converts to this type from the input type.

impl PartialEq<ServerError> for ServerError

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ServerError

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.