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 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
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) } } #[derive(Debug)] pub struct RuleError { pub locations: Vec<Pos>, pub message: String, } #[derive(Debug, Error)] pub struct RuleErrors { pub errors: Vec<RuleError>, } impl Display for RuleErrors { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { for error in &self.errors { writeln!(f, "{}", error.message)?; } Ok(()) } }