use std::sync::Arc;
use gql::{GraphQLError, PathSegment};
pub const INTERNAL_ERROR_MESSAGE: &str = "Internal server error";
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ErrorKind {
Request,
Execution,
}
impl ErrorKind {
#[must_use]
pub const fn is_request(self) -> bool {
matches!(self, Self::Request)
}
#[must_use]
pub const fn is_execution(self) -> bool {
matches!(self, Self::Execution)
}
}
#[derive(Clone, Copy, Debug)]
pub struct ErrorContext<'a> {
kind: ErrorKind,
operation_name: Option<&'a str>,
request_id: Option<&'a str>,
path: Option<&'a [PathSegment]>,
}
impl<'a> ErrorContext<'a> {
pub(crate) fn new(
kind: ErrorKind,
operation_name: Option<&'a str>,
request_id: Option<&'a str>,
path: Option<&'a [PathSegment]>,
) -> Self {
Self {
kind,
operation_name,
request_id,
path,
}
}
#[must_use]
pub const fn kind(&self) -> ErrorKind {
self.kind
}
#[must_use]
pub fn is_request(&self) -> bool {
self.kind.is_request()
}
#[must_use]
pub fn is_execution(&self) -> bool {
self.kind.is_execution()
}
#[must_use]
pub const fn operation_name(&self) -> Option<&'a str> {
self.operation_name
}
#[must_use]
pub const fn request_id(&self) -> Option<&'a str> {
self.request_id
}
#[must_use]
pub const fn prepared_id(&self) -> Option<&'a str> {
self.request_id
}
#[must_use]
pub const fn path(&self) -> Option<&'a [PathSegment]> {
self.path
}
}
pub trait ErrorFormatter: Send + Sync + 'static {
fn format(&self, error: &GraphQLError, context: &ErrorContext<'_>) -> GraphQLError;
}
impl<F> ErrorFormatter for F
where
F: for<'a> Fn(&GraphQLError, &ErrorContext<'a>) -> GraphQLError + Send + Sync + 'static,
{
fn format(&self, error: &GraphQLError, context: &ErrorContext<'_>) -> GraphQLError {
self(error, context)
}
}
#[must_use]
pub fn mask_internal(error: &GraphQLError, context: &ErrorContext<'_>) -> GraphQLError {
if context.is_request() || has_code(error) {
return error.clone();
}
let mut masked = GraphQLError::new(INTERNAL_ERROR_MESSAGE);
for location in error.locations() {
masked = masked.at(*location);
}
if let Some(path) = error.path() {
masked = masked.with_path(path.to_vec());
}
masked
}
fn has_code(error: &GraphQLError) -> bool {
error
.extensions()
.and_then(|extensions| extensions.get("code"))
.is_some()
}
pub(crate) fn format_response_errors(
formatter: &dyn ErrorFormatter,
response: &mut gql::Response,
operation_name: Option<&str>,
request_id: Option<&str>,
default_kind: ErrorKind,
) {
for error in &mut response.errors {
let kind = if error.path().is_some() {
ErrorKind::Execution
} else {
default_kind
};
let context = ErrorContext::new(kind, operation_name, request_id, error.path());
*error = formatter.format(error, &context);
}
}
#[derive(Clone, Copy, Debug, Default)]
pub(crate) struct ResponseMeta<'a> {
pub(crate) operation_name: Option<&'a str>,
pub(crate) request_id: Option<&'a str>,
}
impl<'a> ResponseMeta<'a> {
pub(crate) fn from_request(request: &'a crate::GraphQLRequest) -> Self {
Self {
operation_name: request.operation_name.as_deref(),
request_id: request.prepared_id(),
}
}
pub(crate) const fn none() -> Self {
Self {
operation_name: None,
request_id: None,
}
}
pub(crate) fn with_operation_name(mut self, operation_name: Option<&'a str>) -> Self {
self.operation_name = operation_name.or(self.operation_name);
self
}
pub(crate) fn into_owned(self) -> OwnedResponseMeta {
OwnedResponseMeta {
operation_name: self.operation_name.map(Arc::from),
request_id: self.request_id.map(Arc::from),
}
}
}
#[derive(Clone, Debug, Default)]
pub(crate) struct OwnedResponseMeta {
pub(crate) operation_name: Option<Arc<str>>,
pub(crate) request_id: Option<Arc<str>>,
}