use std::{
any::Any,
panic::{AssertUnwindSafe, catch_unwind},
};
use futures::FutureExt;
use std::future::Future;
use crate::{
error::{GraphQLError, Result},
types::{FieldResult, ResolveFn, ResolverContext, SubscribeFn, SubscriptionStream},
};
pub(crate) const INTERNAL_ERROR_MESSAGE: &str = "Internal server error";
pub(crate) const INTERNAL_ERROR_CODE: &str = "INTERNAL_SERVER_ERROR";
fn internal_error() -> GraphQLError {
GraphQLError::new(INTERNAL_ERROR_MESSAGE).extend("code", INTERNAL_ERROR_CODE)
}
fn caught<T>(result: Result<T, Box<dyn Any + Send>>) -> Result<T, GraphQLError> {
match result {
Ok(value) => Ok(value),
Err(_) => Err(internal_error()),
}
}
#[inline]
pub(crate) fn sync<T>(f: impl FnOnce() -> T) -> Result<T, GraphQLError> {
caught(catch_unwind(AssertUnwindSafe(f)))
}
pub(crate) fn resolver<'a>(
resolve: &'a ResolveFn,
context: ResolverContext<'a>,
) -> impl Future<Output = FieldResult> + 'a {
AssertUnwindSafe(async move { resolve(context).await })
.catch_unwind()
.map(|result| result.unwrap_or_else(|_| Err(internal_error())))
}
pub(crate) fn subscription<'a>(
subscribe: &'a SubscribeFn,
context: ResolverContext<'a>,
) -> impl Future<Output = Result<SubscriptionStream, GraphQLError>> + 'a {
AssertUnwindSafe(async move { subscribe(context).await })
.catch_unwind()
.map(|result| result.unwrap_or_else(|_| Err(internal_error())))
}