Bootstrap

.github/workflows/ci.yml

@@ -99,6 +99,8 @@ jobs:
       matrix:
         include:
           - { feature: <none>, crate: juniper }
+          - { feature: anyhow, crate: juniper }
+          - { feature: anyhow,backtrace, crate: juniper }
           - { feature: bigdecimal, crate: juniper }
           - { feature: bson, crate: juniper }
           - { feature: chrono, crate: juniper }

juniper/Cargo.toml

@@ -31,6 +31,8 @@ default = [
     "url",
     "uuid",
 ]
+anyhow = ["dep:anyhow"]
+backtrace = ["anyhow?/backtrace"]
 bigdecimal = ["dep:bigdecimal", "dep:num-bigint", "dep:ryu"]
 bson = ["dep:bson"]
 chrono = ["dep:chrono"]
@@ -46,7 +48,7 @@ url = ["dep:url"]
 uuid = ["dep:uuid"]
 
 [dependencies]
-anyhow = { version = "1.0.47", default-features = false, optional = true }
+anyhow = { version = "1.0.47", optional = true }
 async-trait = "0.1.39"
 bigdecimal = { version = "0.4", optional = true }
 bson = { version = "2.4", features = ["chrono-0_4"], optional = true }
@@ -81,6 +83,7 @@ bencher = "0.1.2"
 chrono = { version = "0.4.30", features = ["alloc"], default-features = false }
 pretty_assertions = "1.0.0"
 serde_json = "1.0.18"
+serial_test = "2.0"
 tokio = { version = "1.0", features = ["macros", "time", "rt-multi-thread"] }
 
 [[bench]]

juniper/src/integrations/anyhow.rs

@@ -0,0 +1,102 @@
+//! GraphQL support for [`anyhow::Error`].
+
+use crate::{FieldError, IntoFieldError, ScalarValue, Value};
+
+impl<S: ScalarValue> IntoFieldError<S> for anyhow::Error {
+    fn into_field_error(self) -> FieldError<S> {
+        #[cfg(any(nightly, feature = "backtrace"))]
+        let extensions = {
+            let backtrace = self.backtrace().to_string();
+            if backtrace == "disabled backtrace" {
+                Value::Null
+            } else {
+                let mut obj = crate::value::Object::with_capacity(1);
+                _ = obj.add_field(
+                    "backtrace",
+                    Value::List(
+                        backtrace
+                            .split('\n')
+                            .map(|line| Value::Scalar(line.to_owned().into()))
+                            .collect(),
+                    ),
+                );
+                Value::Object(obj)
+            }
+        };
+        #[cfg(not(any(nightly, feature = "backtrace")))]
+        let extensions = Value::Null;
+
+        FieldError::new(self, extensions)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::env;
+
+    use anyhow::anyhow;
+    use serial_test::serial;
+
+    use crate::{
+        execute, graphql_object, graphql_value, graphql_vars, parser::SourcePosition,
+        EmptyMutation, EmptySubscription, RootNode,
+    };
+
+    #[tokio::test]
+    #[serial]
+    async fn simple() {
+        struct Root;
+
+        #[graphql_object]
+        impl Root {
+            fn err() -> anyhow::Result<i32> {
+                Err(anyhow!("errored!"))
+            }
+        }
+
+        let prev_env = env::var("RUST_BACKTRACE").ok();
+        env::set_var("RUST_BACKTRACE", "1");
+
+        const DOC: &str = r#"{
+            err
+        }"#;
+
+        let schema = RootNode::new(
+            Root,
+            EmptyMutation::<()>::new(),
+            EmptySubscription::<()>::new(),
+        );
+
+        let res = execute(DOC, None, &schema, &graphql_vars! {}, &()).await;
+
+        assert!(res.is_ok(), "failed: {:?}", res.unwrap_err());
+
+        let (val, errs) = res.unwrap();
+
+        assert_eq!(val, graphql_value!(null));
+        assert_eq!(errs.len(), 1, "too many errors: {errs:?}");
+
+        let err = errs.first().unwrap();
+
+        assert_eq!(*err.location(), SourcePosition::new(14, 1, 12));
+        assert_eq!(err.path(), &["err"]);
+
+        let err = err.error();
+
+        assert_eq!(err.message(), "errored!");
+        #[cfg(not(any(nightly, feature = "backtrace")))]
+        assert_eq!(err.extensions(), &graphql_value!(null));
+        #[cfg(any(nightly, feature = "backtrace"))]
+        assert_eq!(
+            err.extensions()
+                .as_object_value()
+                .map(|ext| ext.contains_field("backtrace")),
+            Some(true),
+            "no `backtrace` in extensions: {err:?}",
+        );
+
+        if let Some(val) = prev_env {
+            env::set_var("RUST_BACKTRACE", val);
+        }
+    }
+}

juniper/src/integrations/mod.rs

@@ -1,5 +1,7 @@
 //! Provides GraphQLType implementations for some external types
 
+#[cfg(feature = "anyhow")]
+pub mod anyhow;
 #[cfg(feature = "bigdecimal")]
 pub mod bigdecimal;
 #[cfg(feature = "bson")]

tests/integration/tests/codegen_object_attr.rs

@@ -332,7 +332,7 @@ mod fallible_method {
 
     impl<S: ScalarValue> IntoFieldError<S> for CustomError {
         fn into_field_error(self) -> FieldError<S> {
-            juniper::FieldError::new("Whatever", graphql_value!({"code": "some"}))
+            FieldError::new("Whatever", graphql_value!({"code": "some"}))
         }
     }