1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

use crate::Error;
use graphql_parser::query::Value;
use graphql_parser::Pos;
use std::fmt::{Debug, Display, Formatter};

#[derive(Debug, Error)]
#[error("{0}")]
pub struct QueryParseError(pub(crate) String);

#[derive(Debug, Error)]
pub enum QueryError {
    #[error("Not supported.")]
    NotSupported,

    #[error("Expected type \"{expect}\", found {actual}.")]
    ExpectedType { expect: String, actual: Value },

    #[error("Expected type \"{expect}\", found {actual}.")]
    ExpectedJsonType {
        expect: String,
        actual: serde_json::Value,
    },

    #[error("Cannot query field \"{field_name}\" on type \"{object}\".")]
    FieldNotFound { field_name: String, object: String },

    #[error("Unknown operation named \"{name}\"")]
    UnknownOperationNamed { name: String },

    #[error("Type \"{object}\" must have a selection of subfields.")]
    MustHaveSubFields { object: String },

    #[error("Schema is not configured for mutations.")]
    NotConfiguredMutations,

    #[error("Invalid value for enum \"{ty}\".")]
    InvalidEnumValue { ty: String, value: String },

    #[error("Required field \"{field_name}\" for InputObject \"{object}\" does not exist.")]
    RequiredField {
        field_name: String,
        object: &'static str,
    },

    #[error("Variable \"${var_name}\" is not defined")]
    VarNotDefined { var_name: String },

    #[error(
        "Directive \"{directive}\" argument \"{arg_name}\" of type \"{arg_type}\" is required, but it was not provided."
    )]
    RequiredDirectiveArgs {
        directive: &'static str,
        arg_name: &'static str,
        arg_type: &'static str,
    },

    #[error("Unknown directive \"{name}\".")]
    UnknownDirective { name: String },

    #[error("Unknown fragment \"{name}\".")]
    UnknownFragment { name: String },

    #[error("Object \"{object}\" does not implement interface \"{interface}\"")]
    NotImplementedInterface { object: String, interface: String },

    #[error("Unrecognized inline fragment \"{name}\" on type \"{object}\"")]
    UnrecognizedInlineFragment { object: String, name: String },
}

pub trait ErrorWithPosition {
    type Result;
    fn with_position(self, position: Pos) -> PositionError;
}

impl<T: Into<Error>> ErrorWithPosition for T {
    type Result = PositionError;

    fn with_position(self, position: Pos) -> PositionError {
        PositionError {
            position,
            inner: self.into(),
        }
    }
}

#[derive(Debug, Error)]
pub struct PositionError {
    pub position: Pos,
    pub inner: Error,
}

impl PositionError {
    pub fn new(position: Pos, inner: Error) -> Self {
        Self { position, inner }
    }

    pub fn into_inner(self) -> Error {
        self.inner
    }
}

impl Display for PositionError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.inner)
    }
}