fixes for #3718

apollo-router/src/services/snapshots/apollo_router__services__supergraph_service__tests__no_typename_on_interface-2.snap

@@ -0,0 +1,13 @@
+---
+source: apollo-router/src/services/supergraph_service.rs
+expression: with_typename
+---
+{
+  "data": {
+    "dog": {
+      "id": "8765",
+      "__typename": "Dog",
+      "name": "Spot"
+    }
+  }
+}

apollo-router/src/services/snapshots/apollo_router__services__supergraph_service__tests__no_typename_on_interface-3.snap

@@ -0,0 +1,12 @@
+---
+source: apollo-router/src/services/supergraph_service.rs
+expression: with_reversed_fragments
+---
+{
+  "data": {
+    "dog": {
+      "name": "Spot",
+      "id": "0000"
+    }
+  }
+}

apollo-router/src/services/snapshots/apollo_router__services__supergraph_service__tests__no_typename_on_interface.snap

@@ -0,0 +1,12 @@
+---
+source: apollo-router/src/services/supergraph_service.rs
+expression: no_typename
+---
+{
+  "data": {
+    "dog": {
+      "id": "4321",
+      "name": "Spot"
+    }
+  }
+}

apollo-router/src/services/supergraph_service.rs

@@ -2933,10 +2933,10 @@ mod tests {
                 serde_json::json!{{"data":{"dog":{"id":"4321","name":"Spot"}}}}
             ).with_json(
                 serde_json::json!{{"query":"query dog__animal__0{dog{__typename id name}}", "operationName": "dog__animal__0"}},
-                serde_json::json!{{"data":{"dog":{"__typename":"Dog","id":"4321","name":"Spot"}}}}
+                serde_json::json!{{"data":{"dog":{"__typename":"Dog","id":"8765","name":"Spot"}}}}
             ).with_json(
                 serde_json::json!{{"query":"query dog__animal__0{dog{name id}}", "operationName": "dog__animal__0"}},
-                serde_json::json!{{"data":{"dog":{"id":"4321","name":"Spot"}}}}
+                serde_json::json!{{"data":{"dog":{"id":"0000","name":"Spot"}}}}
             ).build()),
         ].into_iter().collect());
 
@@ -3014,6 +3014,7 @@ mod tests {
         let mut stream = service.clone().oneshot(request).await.unwrap();
 
         let no_typename = stream.next_response().await.unwrap();
+        insta::assert_json_snapshot!(no_typename);
 
         let request = supergraph::Request::fake_builder()
             .context(defer_context())
@@ -3057,6 +3058,7 @@ mod tests {
             with_typename,
             no_typename
         );
+        insta::assert_json_snapshot!(with_typename);
 
         let request = supergraph::Request::fake_builder()
             .context(defer_context())
@@ -3099,5 +3101,6 @@ mod tests {
             with_reversed_fragments,
             no_typename
         );
+        insta::assert_json_snapshot!(with_reversed_fragments);
     }
 }

apollo-router/src/spec/query/tests.rs

@@ -522,15 +522,9 @@ fn reformat_response_data_best_effort() {
                         "baz": "2",
                     },
                     "array": [
-                        {
-                            "bar":null,
-                            "baz":"3"
-                        },
+                        {},
                         null,
-                        {
-                            "bar":"5",
-                            "baz":null
-                        }
+                        {}
                     ],
                     "other": null,
                 },

apollo-router/src/spec/selection.rs

@@ -151,15 +151,29 @@ impl Selection {
                     .ok_or_else(|| SpecError::InvalidType(current_type.to_string()))?;
 
                 let fragment_type = FieldType::new_named(type_condition.clone());
+                let known_type = current_type.inner_type_name().map(|s| s.to_string());
 
+                // this is the type we pass when extracting the fragment's selections
+                // If the type condition is a union or interface and the current type implements it, then we want
+                // to keep the current type when extracting the fragment's selections, as it is more precise
+                // than the interface.
+                // If it is not, then we use the type condition
                 let relevant_type = if schema.is_interface(type_condition.as_str()) {
+                    // Query validation should have already verified that current type implements that interface
+                    debug_assert!(
+                        schema.is_subtype(
+                            type_condition.as_str(),
+                            current_type.inner_type_name().unwrap_or("")
+                        ) ||
+                        // if the current type and the type condition are both the same interface, it is still valid
+                        type_condition.as_str()
+                            == current_type.inner_type_name().unwrap_or("")
+                    );
                     current_type
                 } else {
                     &fragment_type
                 };
 
-                let known_type = relevant_type.inner_type_name().map(|s| s.to_string());
-
                 let selection_set = inline_fragment
                     .selection_set()
                     .selection()