Initial fix

Author: tyranron

juniper/src/lib.rs

@@ -9,6 +9,11 @@
 extern crate core;
 extern crate self as juniper;
 
+#[cfg(test)]
+mod for_benches_only {
+    use bencher as _;
+}
+
 use std::fmt;
 
 // These are required by the code generated via the `juniper_codegen` macros.

juniper/src/types/async_await.rs

@@ -159,11 +159,13 @@ where
     ))
 }
 
+#[derive(Debug)]
 struct AsyncField<S> {
     name: String,
     value: Option<Value<S>>,
 }
 
+#[derive(Debug)]
 enum AsyncValue<S> {
     Field(AsyncField<S>),
     Nested(Value<S>),
@@ -184,16 +186,17 @@ where
     use futures::stream::{FuturesOrdered, StreamExt as _};
 
     #[enum_derive(Future)]
-    enum AsyncValueFuture<A, B, C, D> {
-        Field(A),
-        FragmentSpread(B),
-        InlineFragment1(C),
-        InlineFragment2(D),
+    enum AsyncValueFuture<F1, F2, FS, IF1, IF2> {
+        Field1(F1),
+        Field2(F2),
+        FragmentSpread(FS),
+        InlineFragment1(IF1),
+        InlineFragment2(IF2),
     }
 
     let mut object = Object::with_capacity(selection_set.len());
 
-    let mut async_values = FuturesOrdered::<AsyncValueFuture<_, _, _, _>>::new();
+    let mut async_values = FuturesOrdered::<AsyncValueFuture<_, _, _, _, _>>::new();
 
     let meta_type = executor
         .schema()
@@ -258,7 +261,7 @@ where
                 let is_non_null = meta_field.field_type.is_non_null();
 
                 let response_name = response_name.to_string();
-                async_values.push_back(AsyncValueFuture::Field(async move {
+                async_values.push_back(AsyncValueFuture::Field1(async move {
                     // TODO: implement custom future type instead of
                     //       two-level boxing.
                     let res = instance
@@ -327,6 +330,19 @@ where
                                 })),
                             ));
                         }
+                    } else if let Ok(Value::Null) = sub_result {
+                        // NOTE: Executing a fragment cannot really result in a `Value::Null`,
+                        //       because it represents a set of fields, so normal execution always
+                        //       results in a `Value::Object`. However, a `Value::Null` is used here
+                        //       to indicate that fragment execution failed somewhere and, because
+                        //       of non-`null` types involved, its error should be propagated to the
+                        //       parent field.
+                        async_values.push_back(AsyncValueFuture::Field2(future::ready(
+                            AsyncValue::Field(AsyncField {
+                                name: String::new(), // doesn't matter here
+                                value: None,
+                            }),
+                        )));
                     } else if let Err(e) = sub_result {
                         sub_exec.push_error_at(e, span.start);
                     }
@@ -371,6 +387,19 @@ where
                                     })),
                                 ));
                             }
+                        } else if let Ok(Value::Null) = sub_result {
+                            // NOTE: Executing a fragment cannot really result in a `Value::Null`,
+                            //       because it represents a set of fields, so normal execution 
+                            //       always results in a `Value::Object`. However, a `Value::Null` 
+                            //       is used here to indicate that fragment execution failed 
+                            //       somewhere and, because of non-`null` types involved, its error 
+                            //       should be propagated to the parent field.
+                            async_values.push_back(AsyncValueFuture::Field2(future::ready(
+                                AsyncValue::Field(AsyncField {
+                                    name: String::new(), // doesn't matter here
+                                    value: None,
+                                }),
+                            )));
                         } else if let Err(e) = sub_result {
                             sub_exec.push_error_at(e, span.start);
                         }

juniper/src/validation/test_harness.rs

@@ -62,6 +62,7 @@ enum FurColor {
     Spotted,
 }
 
+#[expect(dead_code, reason = "GraphQL schema testing")]
 #[derive(Debug)]
 struct ComplexInput {
     required_field: bool,

tests/integration/tests/issue_1287.rs

@@ -17,7 +17,7 @@ struct Query;
 #[graphql_object]
 impl Query {
     fn my_object() -> MyObject {
-        MyObject {}
+        MyObject
     }
 
     fn just_a_field() -> i32 {
@@ -36,18 +36,18 @@ async fn error_propagates_same_way() {
     }";
     // language=GraphQL
     let with_fragment = r"
-        query { 
-            myObject { 
-                ...MyObjectFragment 
-            } 
+        query {
+            myObject {
+                ...MyObjectFragment
+            }
             justAField
         }
-        
-        fragment MyObjectFragment on MyObject { 
-            erroringField 
+
+        fragment MyObjectFragment on MyObject {
+            erroringField
         }
     ";
-
+    
     let (expected, _) = juniper::execute(
         without_fragment,
         None,