WIP

Author: tomhoule

graphql_client/tests/interfaces.rs

@@ -99,33 +99,33 @@ fn fragment_in_interface() {
         response_data,
         ResponseData {
             everything: Some(vec![
-                RustMyQueryEverything {
+                RustInterfaceWithFragmentQueryEverything {
                     name: "Audrey Lorde".to_string(),
                     public_status: PublicStatus {
                         display_name: false,
                     },
-                    on: RustMyQueryEverythingOn::Person(RustMyQueryEverythingOnPerson {
+                    on: RustInterfaceWithFragmentQueryEverythingOn::Person(RustInterfaceWithFragmentQueryEverythingOnPerson {
                         birthday: Some("1934-02-18".to_string()),
                     })
                 },
-                RustMyQueryEverything {
+                RustInterfaceWithFragmentQueryEverything {
                     name: "Laïka".to_string(),
                     public_status: PublicStatus { display_name: true },
-                    on: RustMyQueryEverythingOn::Dog(RustMyQueryEverythingOnDog {
+                    on: RustInterfaceWithFragmentQueryEverythingOn::Dog(RustInterfaceWithFragmentQueryEverythingOnDog {
                         is_good_dog: true,
                     })
                 },
-                RustMyQueryEverything {
+                RustInterfaceWithFragmentQueryEverything {
                     name: "Mozilla".to_string(),
                     public_status: PublicStatus {
                         display_name: false
                     },
-                    on: RustMyQueryEverythingOn::Organization,
+                    on: RustInterfaceWithFragmentQueryEverythingOn::Organization,
                 },
-                RustMyQueryEverything {
+                RustInterfaceWithFragmentQueryEverything {
                     name: "Norbert".to_string(),
                     public_status: PublicStatus { display_name: true },
-                    on: RustMyQueryEverythingOn::Dog(RustMyQueryEverythingOnDog {
+                    on: RustInterfaceWithFragmentQueryEverythingOn::Dog(RustInterfaceWithFragmentQueryEverythingOnDog {
                         is_good_dog: true
                     }),
                 },

graphql_client/tests/interfaces/interface_with_fragment_query.graphql

@@ -2,10 +2,10 @@ fragment PublicStatus on Named {
   displayName
 }
 
-query MyQuery {
+query InterfaceWithFragmentQuery {
   everything {
-    name
     __typename
+    name
     ...PublicStatus
     ... on Dog {
       isGoodDog

graphql_client_codegen/src/interfaces.rs

@@ -2,15 +2,17 @@ use failure;
 use objects::GqlObjectField;
 use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
-use selection::{Selection, SelectionFragmentSpread, SelectionItem};
+use selection::{Selection, SelectionField, SelectionFragmentSpread, SelectionItem};
 use shared::*;
 use std::borrow::Cow;
 use std::cell::Cell;
 use std::collections::HashSet;
 use unions::union_variants;
 
+/// Represents an Interface type extracted from the schema.
 #[derive(Debug, Clone, PartialEq)]
 pub struct GqlInterface {
+    /// The documentation for the interface. Extracted from the schema.
     pub description: Option<String>,
     /// The set of object types implementing this interface.
     pub implemented_by: HashSet<String>,
@@ -48,6 +50,32 @@ impl GqlInterface {
         )
     }
 
+    fn union_selection(&self, selection: &Selection, query_context: &QueryContext) -> Selection {
+        Selection(
+            selection
+                .0
+                .iter()
+                // Only keep what we can handle
+                .filter(|f| match f {
+                    SelectionItem::InlineFragment(_) => true,
+                    SelectionItem::FragmentSpread(SelectionFragmentSpread { fragment_name }) => {
+                        let fragment = query_context
+                            .fragments
+                            .get(fragment_name)
+                            .ok_or_else(|| format_err!("Unknown fragment: {}", &fragment_name))
+                            // TODO: fix this
+                            .unwrap();
+
+                        // only the fragments _not_ on the interface
+                        fragment.on != self.name
+                    },
+                    SelectionItem::Field(SelectionField { name, .. }) => name == "__typename",
+                }).map(|a| (*a).clone())
+                .collect(),
+
+        )
+    }
+
     /// Create an empty interface. This needs to be mutated before it is useful.
     pub(crate) fn new(name: Cow<str>, description: Option<&str>) -> GqlInterface {
         GqlInterface {
@@ -102,24 +130,15 @@ impl GqlInterface {
 
         selection
             .extract_typename()
-            .ok_or_else(|| format_err!("Missing __typename in selection for {}", prefix))?;
-
-        let union_selection = Selection(
-            selection
-                .0
-                .iter()
-                // Only keep what we can handle
-                .filter(|f| match f {
-                    SelectionItem::InlineFragment(_) | SelectionItem::FragmentSpread(_) => true,
-                    SelectionItem::Field(_) => false,
-                }).map(|a| (*a).clone())
-                .collect(),
-        );
+            .ok_or_else(|| format_err!("Missing __typename in selection for the {} interface (type: {})", prefix, self.name))?;
 
         let object_fields =
             self.response_fields_for_selection(query_context, &selection, prefix)?;
 
         let object_children = self.field_impls_for_selection(query_context, &selection, prefix)?;
+
+        let union_selection = self.union_selection(&selection, &query_context);
+
         let (mut union_variants, union_children, used_variants) =
             union_variants(&union_selection, query_context, prefix)?;
 
@@ -164,3 +183,44 @@ impl GqlInterface {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // to be improved
+    #[test]
+    fn union_selection_works() {
+        let iface = GqlInterface {
+            description: None,
+            implemented_by: HashSet::new(),
+            name: "MyInterface".into(),
+            fields: vec![],
+            is_required: Cell::new(true),
+        };
+
+        let context = QueryContext::new_empty();
+
+        let selection = Selection(vec![]);
+
+        assert_eq!(iface.union_selection(&selection, &context), Selection(vec![]));
+    }
+
+    // to be improved
+    #[test]
+    fn object_selection_works() {
+        let iface = GqlInterface {
+            description: None,
+            implemented_by: HashSet::new(),
+            name: "MyInterface".into(),
+            fields: vec![],
+            is_required: Cell::new(true),
+        };
+
+        let context = QueryContext::new_empty();
+
+        let selection = Selection(vec![]);
+
+        assert_eq!(iface.object_selection(&selection, &context), Selection(vec![]));
+    }
+}