fix: don't drop data when schema expects a list (apollographql#326)

If the schema's output type is a list (`[Type]`) but the response is not a list, this change wraps the response in a list as a convenience to the user.

Without this change, the router's response formatting will silently drop the data.

This is probably the right design choice because the Selection syntax is "agnostic" to arrays, so there's no way for the user to indicate how to handle this situation, nor is there a way to detect this situation during validation (at least not until we have a JSON spec to also validation against.)

Author: lennyburdette

apollo-router/src/plugins/connectors/response_formatting/engine.rs

@@ -278,4 +278,48 @@ mod tests {
             .unwrap()
         );
     }
+
+    #[test]
+    fn test_list_coercion() {
+        let schema = Schema::parse_and_validate(
+            "type Query {hello: [Hello]} interface Hello{id:ID} type Foo implements Hello{id:ID a:ID}",
+            "schema.graphql",
+        )
+        .unwrap();
+
+        let document = ExecutableDocument::parse_and_validate(
+            &schema,
+            "{hello{__typename id ...on Foo {a}}}",
+            "op.graphql",
+        )
+        .unwrap();
+
+        let data = serde_json_bytes::json!({
+            "hello": {
+                "id": "123",
+                "a": "a"
+            }
+        });
+
+        let mut diagnostics = vec![];
+        let result = super::execute(
+            &schema,
+            &document,
+            diagnostics.as_mut(),
+            data.as_object().unwrap().clone(),
+        );
+
+        assert_eq!(
+            result,
+            *serde_json_bytes::json!({
+                "hello": [{
+                    "__typename": "Foo",
+                    "id": "123",
+                    "a": "a"
+                }]
+            })
+            .as_object()
+            .unwrap()
+        );
+    }
 }

apollo-router/src/plugins/connectors/response_formatting/result_coercion.rs

@@ -40,7 +40,32 @@ pub(super) fn complete_value<'a, 'b>(
             let ty_name = match ty {
                 Type::Named(name) | Type::NonNullNamed(name) => name,
                 Type::List(_) | Type::NonNullList(_) => {
-                    field_diagnostic!("List type {ty} resolved to an object")
+                    // If the schema expects a list, but the response is an object,
+                    // we'll wrap it in a list to make a valid response. This might
+                    // be unexpected, but it the alternative is doing nothing and
+                    // letting the router's response validation silently drop the data.
+                    // We'll also emit a diagnostic to help users identify this mismatch.
+                    diagnostics.push(FormattingDiagnostic::for_path(
+                        format!("List type {ty} resolved to an object"),
+                        path,
+                    ));
+
+                    let inner_path = LinkedPathElement {
+                        element: ResponseDataPathElement::ListIndex(0),
+                        next: path,
+                    };
+
+                    let inner_resolved = JsonValue::Array(vec![resolved.clone()]);
+
+                    return complete_value(
+                        schema,
+                        document,
+                        diagnostics,
+                        Some(&inner_path),
+                        ty,
+                        &inner_resolved,
+                        fields,
+                    );
                 }
             };