refactor all errors to error type

Author: olirice

src/builder.rs

@@ -3,11 +3,11 @@ use thiserror::Error;
 
 /// Central error type for all pg_graphql operations.
 /// This replaces string-based error handling with strongly-typed variants.
-#[derive(Debug, Error)]
+#[derive(Debug, Error, Clone)]
 pub enum GraphQLError {
     /// GraphQL query parsing errors
     #[error("Parse error: {0}")]
-    Parse(#[from] GraphQLParseError),
+    Parse(String),
 
     /// Field resolution errors
     #[error("Field not found: {field} on type {type_name}")]
@@ -18,7 +18,36 @@ pub enum GraphQLError {
     Operation { context: String, message: String },
 }
 
+impl From<GraphQLParseError> for GraphQLError {
+    fn from(err: GraphQLParseError) -> Self {
+        Self::Parse(err.to_string())
+    }
+}
+
+impl From<String> for GraphQLError {
+    fn from(err: String) -> Self {
+        Self::Operation {
+            context: "Error".to_string(),
+            message: err,
+        }
+    }
+}
+
+impl From<&str> for GraphQLError {
+    fn from(err: &str) -> Self {
+        Self::Operation {
+            context: "Error".to_string(),
+            message: err.to_string(),
+        }
+    }
+}
+
 impl GraphQLError {
+    /// Creates a parse error
+    pub fn parse(message: impl Into<String>) -> Self {
+        Self::Parse(message.into())
+    }
+
     /// Creates a field not found error
     pub fn field_not_found(field: impl Into<String>, type_name: impl Into<String>) -> Self {
         Self::FieldNotFound {

src/error.rs

@@ -6,6 +6,8 @@ were not provided by the user.
 */
 use std::collections::HashMap;
 
+use crate::error::{GraphQLError, GraphQLResult};
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum Value {
     Absent,
@@ -29,7 +31,7 @@ pub enum Number {
     Float(f64),
 }
 
-pub fn json_to_gson(val: &serde_json::Value) -> Result<Value, String> {
+pub fn json_to_gson(val: &serde_json::Value) -> GraphQLResult<Value> {
     use serde_json::Value as JsonValue;
 
     let v = match val {
@@ -52,9 +54,9 @@ pub fn json_to_gson(val: &serde_json::Value) -> Result<Value, String> {
                     Value::Number(i_val)
                 }
                 None => {
-                    let f_val: f64 = x
-                        .as_f64()
-                        .ok_or("Failed to handle numeric user input".to_string())?;
+                    let f_val: f64 = x.as_f64().ok_or_else(|| {
+                        GraphQLError::type_error("Failed to handle numeric user input")
+                    })?;
                     Value::Number(Number::Float(f_val))
                 }
             }
@@ -71,12 +73,12 @@ pub fn json_to_gson(val: &serde_json::Value) -> Result<Value, String> {
     Ok(v)
 }
 
-pub fn gson_to_json(val: &Value) -> Result<serde_json::Value, String> {
+pub fn gson_to_json(val: &Value) -> GraphQLResult<serde_json::Value> {
     use serde_json::Value as JsonValue;
 
     let v = match val {
         Value::Absent => {
-            return Err("Encounterd `Absent` value while transforming between GraphQL intermediate object notation and JSON".to_string())
+            return Err(GraphQLError::internal("Encountered `Absent` value while transforming between GraphQL intermediate object notation and JSON"))
         },
         Value::Null => JsonValue::Null,
         Value::Boolean(x) => JsonValue::Bool(x.to_owned()),

src/gson.rs

@@ -58,7 +58,9 @@ fn resolve(
                 }
                 Err(err) => GraphQLResponse {
                     data: Omit::Omitted,
-                    errors: Omit::Present(vec![ErrorMessage { message: err }]),
+                    errors: Omit::Present(vec![ErrorMessage {
+                        message: err.to_string(),
+                    }]),
                 },
             }
         }

src/lib.rs

@@ -3,6 +3,7 @@ use std::{collections::HashMap, hash::Hash};
 use graphql_parser::query::{Field, Text, Value};
 use indexmap::IndexMap;
 
+use crate::error::{GraphQLError, GraphQLResult};
 use crate::parser_util::alias_or_name;
 
 /// Merges duplicates in a vector of fields. The fields in the vector are added to a
@@ -12,7 +13,7 @@ use crate::parser_util::alias_or_name;
 ///
 /// The map is an `IndexMap` to ensure iteration order of the fields is preserved.
 /// This prevents tests from being flaky due to field order changing between test runs.
-pub fn merge<'a, 'b, T>(fields: Vec<Field<'a, T>>) -> Result<Vec<Field<'a, T>>, String>
+pub fn merge<'a, 'b, T>(fields: Vec<Field<'a, T>>) -> GraphQLResult<Vec<Field<'a, T>>>
 where
     T: Text<'a> + Eq + AsRef<str>,
     T::Value: Hash,
@@ -41,23 +42,23 @@ where
     Ok(fields)
 }
 
-fn can_merge<'a, T>(field_a: &Field<'a, T>, field_b: &Field<'a, T>) -> Result<bool, String>
+fn can_merge<'a, T>(field_a: &Field<'a, T>, field_b: &Field<'a, T>) -> GraphQLResult<bool>
 where
     T: Text<'a> + Eq + AsRef<str>,
     T::Value: Hash,
 {
     if field_a.name != field_b.name {
-        return Err(format!(
+        return Err(GraphQLError::validation(format!(
             "Fields `{}` and `{}` are different",
             field_a.name.as_ref(),
             field_b.name.as_ref(),
-        ));
+        )));
     }
     if !same_arguments(&field_a.arguments, &field_b.arguments) {
-        return Err(format!(
+        return Err(GraphQLError::validation(format!(
             "Two fields named `{}` have different arguments",
             field_a.name.as_ref(),
-        ));
+        )));
     }
 
     Ok(true)