Add support for interfaces

Author: tomhoule

graphql_query_derive/src/constants.rs

@@ -1,3 +1,5 @@
+use field_type::FieldType;
+use objects::GqlObjectField;
 use proc_macro2::{Ident, Span};
 
 pub const TYPENAME_FIELD: &'static str = "__typename";
@@ -9,3 +11,12 @@ pub fn string_type() -> Ident {
 pub fn float_type() -> Ident {
     Ident::new("Float", Span::call_site())
 }
+
+pub fn typename_field() -> GqlObjectField {
+    GqlObjectField {
+        name: TYPENAME_FIELD.to_string(),
+        /// Non-nullable, see spec:
+        /// https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md
+        type_: FieldType::Named(string_type()),
+    }
+}

graphql_query_derive/src/field_type.rs

@@ -5,7 +5,7 @@ use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
 use schema::DEFAULT_SCALARS;
 
-#[derive(Debug, PartialEq, Hash)]
+#[derive(Clone, Debug, PartialEq, Hash)]
 pub enum FieldType {
     Named(Ident),
     Optional(Box<FieldType>),

graphql_query_derive/src/interfaces.rs

@@ -1,7 +1,12 @@
+use constants::*;
+use failure;
 use objects::GqlObjectField;
 use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
-use selection::Selection;
+use selection::{Selection, SelectionItem};
+use shared::*;
+use std::borrow::Cow;
+use unions::union_variants;
 
 #[derive(Debug, PartialEq)]
 pub struct GqlInterface {
@@ -11,16 +16,81 @@ pub struct GqlInterface {
 }
 
 impl GqlInterface {
+    pub fn new(name: Cow<str>) -> GqlInterface {
+        GqlInterface {
+            name: name.into_owned(),
+            implemented_by: Vec::new(),
+            fields: vec![],
+        }
+    }
+
     pub fn response_for_selection(
         &self,
-        _query_context: &QueryContext,
-        _selection: &Selection,
+        query_context: &QueryContext,
+        selection: &Selection,
         prefix: &str,
-    ) -> TokenStream {
+    ) -> Result<TokenStream, failure::Error> {
         let name = Ident::new(&prefix, Span::call_site());
-        quote! {
-            #[derive(Debug, Deserialize)]
-            pub struct #name;
-        }
+
+        selection
+            .extract_typename()
+            .ok_or_else(|| format_err!("Missing __typename in selection for {}", prefix))?;
+
+        let object_selection = Selection(
+            selection.0.iter()
+            // Only keep what we can handle
+            .filter(|f| match f {
+                SelectionItem::Field(f) => f.name != "__typename",
+                SelectionItem::FragmentSpread(_) => true,
+                SelectionItem::InlineFragment(_) => false,
+            }).map(|a| (*a).clone()).collect(),
+        );
+
+        let union_selection = Selection(
+            selection.0.iter()
+            // Only keep what we can handle
+            .filter(|f| match f {
+                SelectionItem::InlineFragment(_) => true,
+                SelectionItem::Field(_) | SelectionItem::FragmentSpread(_) => false,
+            }).map(|a| (*a).clone()).collect(),
+        );
+
+        let object_fields =
+            response_fields_for_selection(&self.fields, query_context, &object_selection, prefix)?;
+
+        let object_children =
+            field_impls_for_selection(&self.fields, query_context, &object_selection, prefix)?;
+        let (union_variants, union_children) =
+            union_variants(&union_selection, query_context, prefix)?;
+
+        let attached_enum_name = Ident::new(&format!("{}On", name), Span::call_site());
+        let (attached_enum, last_object_field) = if union_variants.len() > 0 {
+            let attached_enum = quote! {
+                #[derive(Deserialize, Debug, Serialize)]
+                #[serde(tag = "__typename")]
+                pub enum #attached_enum_name {
+                    #(#union_variants,)*
+                }
+            };
+            let last_object_field = quote!(#[serde(flatten)] on: #attached_enum_name,);
+            (attached_enum, last_object_field)
+        } else {
+            (quote!(), quote!())
+        };
+
+        Ok(quote! {
+
+            #(#object_children)*
+
+            #(#union_children)*
+
+            #attached_enum
+
+            #[derive(Debug, Serialize, Deserialize)]
+            pub struct #name {
+                #(#object_fields,)*
+                #last_object_field
+            }
+        })
     }
 }

graphql_query_derive/src/objects.rs

@@ -13,7 +13,7 @@ pub struct GqlObject {
     pub fields: Vec<GqlObjectField>,
 }
 
-#[derive(Debug, PartialEq, Hash)]
+#[derive(Clone, Debug, PartialEq, Hash)]
 pub struct GqlObjectField {
     pub name: String,
     pub type_: FieldType,
@@ -23,12 +23,7 @@ impl GqlObject {
     pub fn new(name: Cow<str>) -> GqlObject {
         GqlObject {
             name: name.into_owned(),
-            fields: vec![GqlObjectField {
-                name: TYPENAME_FIELD.to_string(),
-                /// Non-nullable, see spec:
-                /// https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md
-                type_: FieldType::Named(string_type()),
-            }],
+            fields: vec![typename_field()],
         }
     }
 

graphql_query_derive/src/query.rs

@@ -92,7 +92,7 @@ impl QueryContext {
         } else if let Some(obj) = self.schema.objects.get(ty) {
             obj.response_for_selection(self, &selection, prefix)
         } else if let Some(iface) = self.schema.interfaces.get(ty) {
-            Ok(iface.response_for_selection(self, &selection, prefix))
+            iface.response_for_selection(self, &selection, prefix)
         } else if let Some(unn) = self.schema.unions.get(ty) {
             unn.response_for_selection(self, &selection, prefix)
         } else {

graphql_query_derive/src/schema.rs

@@ -234,21 +234,14 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
                         schema.unions.insert(union.name, GqlUnion(tys));
                     }
                     schema::TypeDefinition::Interface(interface) => {
-                        schema.interfaces.insert(
-                            interface.name.clone(),
-                            GqlInterface {
-                                name: interface.name,
-                                implemented_by: Vec::new(),
-                                fields: interface
-                                    .fields
-                                    .iter()
-                                    .map(|f| GqlObjectField {
-                                        name: f.name.clone(),
-                                        type_: FieldType::from(f.field_type.clone()),
-                                    })
-                                    .collect(),
-                            },
-                        );
+                        let mut iface = GqlInterface::new(interface.name.clone().into());
+                        iface
+                            .fields
+                            .extend(interface.fields.iter().map(|f| GqlObjectField {
+                                name: f.name.clone(),
+                                type_: FieldType::from(f.field_type.clone()),
+                            }));
+                        schema.interfaces.insert(interface.name, iface);
                     }
                     schema::TypeDefinition::InputObject(input) => {
                         schema
@@ -342,21 +335,18 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
                         .insert(name.clone(), GqlObject::from_introspected_schema_json(ty));
                 }
                 Some(__TypeKind::INTERFACE) => {
-                    let iface = GqlInterface {
-                        name: name.clone(),
-                        implemented_by: Vec::new(),
-                        fields: ty
-                            .fields
+                    let mut iface = GqlInterface::new(name.clone().into());
+                    iface.fields.extend(
+                        ty.fields
                             .clone()
                             .expect("interface fields")
                             .into_iter()
                             .filter_map(|f| f)
                             .map(|f| GqlObjectField {
                                 name: f.name.expect("field name"),
                                 type_: FieldType::from(f.type_.expect("field type")),
-                            })
-                            .collect(),
-                    };
+                            }),
+                    );
                     schema.interfaces.insert(name, iface);
                 }
                 Some(__TypeKind::INPUT_OBJECT) => {

graphql_query_derive/src/selection.rs

@@ -1,24 +1,24 @@
 use constants::*;
 use graphql_parser::query::SelectionSet;
 
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct SelectionField {
     pub name: String,
     pub fields: Selection,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct SelectionFragmentSpread {
     pub fragment_name: String,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct SelectionInlineFragment {
     pub on: String,
     pub fields: Selection,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum SelectionItem {
     Field(SelectionField),
     FragmentSpread(SelectionFragmentSpread),
@@ -36,7 +36,7 @@ impl SelectionItem {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct Selection(pub Vec<SelectionItem>);
 
 impl Selection {

graphql_query_derive/src/shared.rs

@@ -82,7 +82,9 @@ pub fn response_fields_for_selection(
                     #field_name: #type_name
                 })
             }
-            SelectionItem::InlineFragment(_) => unreachable!("inline fragment on object field"),
+            SelectionItem::InlineFragment(_) => {
+                Err(format_err!("inline fragment on object field"))?
+            }
         })
         .collect()
 }

graphql_query_derive/src/unions.rs

@@ -37,8 +37,8 @@ pub fn union_variants(
             })
             .map(|item| {
                 match item {
-                    SelectionItem::Field(_) => panic!("field selection on union"),
-                    SelectionItem::FragmentSpread(_) => panic!("fragment spread on union"),
+                    SelectionItem::Field(_) => Err(format_err!("field selection on union"))?,
+                    SelectionItem::FragmentSpread(_) => Err(format_err!("fragment spread on union"))?,
                     SelectionItem::InlineFragment(frag) => {
                         let variant_name = Ident::new(&frag.on, Span::call_site());
 

tests/interfaces.rs

@@ -0,0 +1,30 @@
+#[macro_use]
+extern crate graphql_client;
+#[macro_use]
+extern crate serde_derive;
+extern crate serde;
+extern crate serde_json;
+
+const RESPONSE: &'static str = include_str!("interfaces/interface_response.json");
+
+#[derive(GraphQLQuery)]
+#[GraphQLQuery(
+    query_path = "tests/interfaces/interface_query.graphql",
+    schema_path = "tests/interfaces/interface_schema.graphql"
+)]
+#[allow(dead_code)]
+struct InterfaceQuery;
+
+#[test]
+fn interface_deserialization() {
+    println!("{:?}", RESPONSE);
+    let response_data: interface_query::ResponseData = serde_json::from_str(RESPONSE).unwrap();
+
+    println!("{:?}", response_data);
+
+    let expected = r##"ResponseData { everything: Some([RustMyQueryEverything { name: "Audrey Lorde", on: Person(RustMyQueryEverythingOnPerson { birthday: Some("1934-02-18") }) }, RustMyQueryEverything { name: "Laïka", on: Dog(RustMyQueryEverythingOnDog { isGoodDog: true }) }, RustMyQueryEverything { name: "Mozilla", on: Organization(RustMyQueryEverythingOnOrganization { industry: OTHER }) }, RustMyQueryEverything { name: "Norbert", on: Dog(RustMyQueryEverythingOnDog { isGoodDog: true }) }]) }"##;
+
+    assert_eq!(format!("{:?}", response_data), expected);
+
+    assert_eq!(response_data.everything.map(|names| names.len()), Some(4));
+}