Merge pull request #27 from tomhoule/interfaces

Support 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/fragments.rs

@@ -10,21 +10,19 @@ pub struct GqlFragment {
 }
 
 impl GqlFragment {
-    pub fn to_rust(&self, context: &QueryContext) -> TokenStream {
+    pub fn to_rust(&self, context: &QueryContext) -> Result<TokenStream, ::failure::Error> {
         let name_ident = Ident::new(&self.name, Span::call_site());
         let object = context.schema.objects.get(&self.on).expect("oh, noes");
-        let field_impls = object
-            .field_impls_for_selection(context, &self.selection, &self.name)
-            .unwrap();
-        let fields = object.response_fields_for_selection(context, &self.selection, &self.name);
+        let field_impls = object.field_impls_for_selection(context, &self.selection, &self.name)?;
+        let fields = object.response_fields_for_selection(context, &self.selection, &self.name)?;
 
-        quote!{
+        Ok(quote!{
             #[derive(Debug, Deserialize, Serialize)]
             pub struct #name_ident {
                 #(#fields,)*
             }
 
             #(#field_impls)*
-        }
+        })
     }
 }

graphql_query_derive/src/interfaces.rs

@@ -1,26 +1,106 @@
+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 std::collections::HashSet;
+use unions::union_variants;
 
 #[derive(Debug, PartialEq)]
 pub struct GqlInterface {
-    pub implemented_by: Vec<String>,
+    pub implemented_by: HashSet<String>,
     pub name: String,
     pub fields: Vec<GqlObjectField>,
 }
 
 impl GqlInterface {
+    pub fn new(name: Cow<str>) -> GqlInterface {
+        GqlInterface {
+            name: name.into_owned(),
+            implemented_by: HashSet::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 (mut union_variants, union_children, used_variants) =
+            union_variants(&union_selection, query_context, prefix)?;
+
+        union_variants.extend(
+            self.implemented_by
+                .iter()
+                .filter(|obj| used_variants.iter().find(|v| v == obj).is_none())
+                .map(|v| {
+                    let v = Ident::new(v, Span::call_site());
+                    quote!(#v)
+                }),
+        );
+
+        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/lib.rs

@@ -66,8 +66,6 @@ fn read_file(
 }
 
 fn impl_gql_query(input: &syn::DeriveInput) -> Result<TokenStream, failure::Error> {
-    use std::io::prelude::*;
-
     let cargo_manifest_dir =
         ::std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR env variable is defined");
 

graphql_query_derive/src/objects.rs

@@ -1,11 +1,10 @@
 use constants::*;
 use failure;
 use field_type::FieldType;
-use heck::{CamelCase, SnakeCase};
 use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
 use selection::*;
-use shared::render_object_field;
+use shared::{field_impls_for_selection, response_fields_for_selection};
 use std::borrow::Cow;
 
 #[derive(Debug, PartialEq)]
@@ -14,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,
@@ -24,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()],
         }
     }
 
@@ -64,7 +58,7 @@ impl GqlObject {
         prefix: &str,
     ) -> Result<TokenStream, failure::Error> {
         let name = Ident::new(prefix, Span::call_site());
-        let fields = self.response_fields_for_selection(query_context, selection, prefix);
+        let fields = self.response_fields_for_selection(query_context, selection, prefix)?;
         let field_impls = self.field_impls_for_selection(query_context, selection, &prefix)?;
         Ok(quote! {
             #(#field_impls)*
@@ -82,69 +76,15 @@ impl GqlObject {
         selection: &Selection,
         prefix: &str,
     ) -> Result<Vec<TokenStream>, failure::Error> {
-        selection
-            .0
-            .iter()
-            .map(|selected| {
-                if let SelectionItem::Field(selected) = selected {
-                    let ty = self
-                        .fields
-                        .iter()
-                        .find(|f| f.name == selected.name)
-                        .ok_or_else(|| format_err!("could not find field `{}`", selected.name))?
-                        .type_
-                        .inner_name_string();
-                    let prefix = format!(
-                        "{}{}",
-                        prefix.to_camel_case(),
-                        selected.name.to_camel_case()
-                    );
-                    query_context.maybe_expand_field(&ty, &selected.fields, &prefix)
-                } else {
-                    Ok(quote!())
-                }
-            })
-            .collect()
+        field_impls_for_selection(&self.fields, query_context, selection, prefix)
     }
 
     pub fn response_fields_for_selection(
         &self,
         query_context: &QueryContext,
         selection: &Selection,
         prefix: &str,
-    ) -> Vec<TokenStream> {
-        let mut fields = Vec::new();
-
-        for item in selection.0.iter() {
-            match item {
-                SelectionItem::Field(f) => {
-                    let name = &f.name;
-
-                    let ty = &self
-                        .fields
-                        .iter()
-                        .find(|field| field.name.as_str() == name.as_str())
-                        .expect("could not find field")
-                        .type_;
-                    let ty = ty.to_rust(
-                        query_context,
-                        &format!("{}{}", prefix.to_camel_case(), name.to_camel_case()),
-                    );
-                    fields.push(render_object_field(name, ty));
-                }
-                SelectionItem::FragmentSpread(fragment) => {
-                    let field_name =
-                        Ident::new(&fragment.fragment_name.to_snake_case(), Span::call_site());
-                    let type_name = Ident::new(&fragment.fragment_name, Span::call_site());
-                    fields.push(quote!{
-                        #[serde(flatten)]
-                        #field_name: #type_name
-                    })
-                }
-                SelectionItem::InlineFragment(_) => unreachable!("inline fragment on object field"),
-            }
-        }
-
-        fields
+    ) -> Result<Vec<TokenStream>, failure::Error> {
+        response_fields_for_selection(&self.fields, query_context, selection, prefix)
     }
 }

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 {