fix(executor): handle subgraph errors with extensions correctly (#494)

Ref ROUTER-157

When subgraphs returns an error with extensions but without `data`, the
deserialization was breaking due to the issue ->
cloudwego/sonic-rs#114

A manual deserialization is needed in this case

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Author: ardatan

lib/executor/src/response/graphql_error.rs

@@ -1,6 +1,7 @@
+use core::fmt;
 use graphql_parser::Pos;
 use graphql_tools::validation::utils::ValidationError;
-use serde::{Deserialize, Serialize};
+use serde::{de, Deserialize, Deserializer, Serialize};
 use sonic_rs::Value;
 use std::collections::HashMap;
 
@@ -177,17 +178,74 @@ impl GraphQLErrorPath {
     }
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize, Default)]
+#[derive(Clone, Debug, Serialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct GraphQLErrorExtensions {
-    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub code: Option<String>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub service_name: Option<String>,
     #[serde(flatten)]
     pub extensions: HashMap<String, Value>,
 }
 
+// Workaround for https://github.com/cloudwego/sonic-rs/issues/114
+
+impl<'de> Deserialize<'de> for GraphQLErrorExtensions {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct GraphQLErrorExtensionsVisitor;
+
+        impl<'de> de::Visitor<'de> for GraphQLErrorExtensionsVisitor {
+            type Value = GraphQLErrorExtensions;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a map for GraphQLErrorExtensions")
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::MapAccess<'de>,
+            {
+                let mut code = None;
+                let mut service_name = None;
+                let mut extensions = HashMap::new();
+
+                while let Some(key) = map.next_key::<String>()? {
+                    match key.as_str() {
+                        "code" => {
+                            if code.is_some() {
+                                return Err(de::Error::duplicate_field("code"));
+                            }
+                            code = Some(map.next_value()?);
+                        }
+                        "serviceName" => {
+                            if service_name.is_some() {
+                                return Err(de::Error::duplicate_field("serviceName"));
+                            }
+                            service_name = Some(map.next_value()?);
+                        }
+                        other_key => {
+                            let value: Value = map.next_value()?;
+                            extensions.insert(other_key.to_string(), value);
+                        }
+                    }
+                }
+
+                Ok(GraphQLErrorExtensions {
+                    code,
+                    service_name,
+                    extensions,
+                })
+            }
+        }
+
+        deserializer.deserialize_map(GraphQLErrorExtensionsVisitor)
+    }
+}
+
 impl GraphQLErrorExtensions {
     pub fn new_from_code(code: &str) -> Self {
         GraphQLErrorExtensions {

lib/executor/src/response/subgraph_response.rs

@@ -80,3 +80,37 @@ impl<'de> de::Deserialize<'de> for SubgraphResponse<'de> {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    // When subgraph returns an error with custom extensions but without `data` field
+    #[test]
+    fn deserialize_response_without_data_with_errors_with_extensions() {
+        let json_response = r#"
+        {
+            "errors": [
+                {
+                    "message": "Random error from subgraph",
+                    "extensions":{
+                        "statusCode": 400
+                    }
+                }
+            ]
+        }"#;
+
+        let response: super::SubgraphResponse =
+            sonic_rs::from_str(json_response).expect("Failed to deserialize");
+
+        assert!(response.data.is_null());
+        let errors = response.errors.as_ref().unwrap();
+        insta::assert_snapshot!(sonic_rs::to_string_pretty(&errors).unwrap(), @r###"
+        [
+          {
+            "message": "Random error from subgraph",
+            "extensions": {
+              "statusCode": 400
+            }
+          }
+        ]"###);
+    }
+}