Enforce the presence of __typename on union selections

Author: tomhoule

graphql_query_derive/src/objects.rs

@@ -35,27 +35,22 @@ impl GqlObject {
 
     pub fn from_graphql_parser_object(obj: ::graphql_parser::schema::ObjectType) -> Self {
         let mut item = GqlObject::new(obj.name.into());
-        item.fields.extend(obj.fields.iter()
-                                    .map(|f| GqlObjectField {
-                                        name: f.name.clone(),
-                                        type_: FieldType::from(f.field_type.clone()),
-                                    }));
+        item.fields
+            .extend(obj.fields.iter().map(|f| GqlObjectField {
+                name: f.name.clone(),
+                type_: FieldType::from(f.field_type.clone()),
+            }));
         item
     }
 
     pub fn from_introspected_schema_json(obj: &::introspection_response::FullType) -> Self {
         let mut item = GqlObject::new(obj.name.clone().expect("missing object name").into());
-        let fields = obj
-            .fields
-            .clone()
-            .unwrap()
-            .into_iter()
-            .filter_map(|t| {
-                t.map(|t| GqlObjectField {
-                    name: t.name.expect("field name"),
-                    type_: FieldType::from(t.type_.expect("field type")),
-                })
-            });
+        let fields = obj.fields.clone().unwrap().into_iter().filter_map(|t| {
+            t.map(|t| GqlObjectField {
+                name: t.name.expect("field name"),
+                type_: FieldType::from(t.type_.expect("field type")),
+            })
+        });
 
         item.fields.extend(fields);
 

graphql_query_derive/src/schema.rs

@@ -192,10 +192,9 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
                                 .or_insert_with(|| vec![name.clone()]);
                         }
 
-                        schema.objects.insert(
-                            obj.name.clone(),
-                            GqlObject::from_graphql_parser_object(obj),
-                        );
+                        schema
+                            .objects
+                            .insert(obj.name.clone(), GqlObject::from_graphql_parser_object(obj));
                     }
                     schema::TypeDefinition::Enum(enm) => {
                         schema.enums.insert(
@@ -350,8 +349,8 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
 
 #[cfg(test)]
 mod tests {
-    use constants::*;
     use super::*;
+    use constants::*;
     use proc_macro2::{Ident, Span};
 
     #[test]

graphql_query_derive/src/unions.rs

@@ -1,3 +1,4 @@
+use constants::*;
 use failure;
 use heck::SnakeCase;
 use proc_macro2::{Ident, Span, TokenStream};
@@ -13,6 +14,8 @@ pub struct GqlUnion(pub BTreeSet<String>);
 enum UnionError {
     #[fail(display = "Unknown type: {}", ty)]
     UnknownType { ty: String },
+    #[fail(display = "Missing __typename in selection for {}", union_name)]
+    MissingTypename { union_name: String }
 }
 
 impl GqlUnion {
@@ -24,13 +27,34 @@ impl GqlUnion {
     ) -> Result<TokenStream, failure::Error> {
         let struct_name = Ident::new(prefix, Span::call_site());
         let mut children_definitions: Vec<TokenStream> = Vec::new();
+
+        let typename_field = selection.0.iter().find(|f| {
+            if let SelectionItem::Field(f) = f {
+                f.name == TYPENAME_FIELD
+            } else {
+                false
+            }
+        });
+
+        if typename_field.is_none() {
+            Err(UnionError::MissingTypename { union_name: prefix.into() })?;
+        }
+
         let variants: Result<Vec<TokenStream>, failure::Error> = selection
             .0
             .iter()
+            // ignore __typename
+            .filter(|item| {
+                if let SelectionItem::Field(f) = item {
+                    f.name != TYPENAME_FIELD
+                } else {
+                    true
+                }
+            })
             .map(|item| {
                 match item {
-                    SelectionItem::Field(_) => unreachable!("field selection on union"),
-                    SelectionItem::FragmentSpread(_) => unreachable!("fragment spread on union"),
+                    SelectionItem::Field(f) => panic!("field selection on union"),
+                    SelectionItem::FragmentSpread(_) => panic!("fragment spread on union"),
                     SelectionItem::InlineFragment(frag) => {
                         let variant_name = Ident::new(&frag.on, Span::call_site());
 
@@ -160,23 +184,23 @@ mod tests {
 
         assert!(result.is_err());
 
-        assert_eq!(format!("{}", result.unwrap_err()), "");
+        assert_eq!(format!("{}", result.unwrap_err()), "Missing __typename in selection for Meow");
     }
 
     #[test]
     fn union_response_for_selection_works() {
         let fields = vec![
+            SelectionItem::Field(SelectionField {
+                name: "__typename".to_string(),
+                fields: Selection(vec![]),
+            }),
             SelectionItem::InlineFragment(SelectionInlineFragment {
                 on: "User".to_string(),
                 fields: Selection(vec![
                     SelectionItem::Field(SelectionField {
                         name: "first_name".to_string(),
                         fields: Selection(vec![]),
                     }),
-                    SelectionItem::Field(SelectionField {
-                        name: "__typename".to_string(),
-                        fields: Selection(vec![]),
-                    }),
                 ]),
             }),
             SelectionItem::InlineFragment(SelectionInlineFragment {
@@ -186,10 +210,6 @@ mod tests {
                         name: "title".to_string(),
                         fields: Selection(vec![]),
                     }),
-                    SelectionItem::Field(SelectionField {
-                        name: "__typename".to_string(),
-                        fields: Selection(vec![]),
-                    }),
                 ]),
             }),
         ];
@@ -207,13 +227,17 @@ mod tests {
             GqlObject {
                 name: "User".to_string(),
                 fields: vec![
+                    GqlObjectField {
+                        name: "__typename".to_string(),
+                        type_: FieldType::Named(string_type()),
+                    },
                     GqlObjectField {
                         name: "first_name".to_string(),
-                        type_: FieldType::Named(Ident::new("String", Span::call_site())),
+                        type_: FieldType::Named(string_type()),
                     },
                     GqlObjectField {
                         name: "last_name".to_string(),
-                        type_: FieldType::Named(Ident::new("String", Span::call_site())),
+                        type_: FieldType::Named(string_type()),
                     },
                     GqlObjectField {
                         name: "created_at".to_string(),
@@ -228,6 +252,10 @@ mod tests {
             GqlObject {
                 name: "Organization".to_string(),
                 fields: vec![
+                    GqlObjectField {
+                        name: "__typename".to_string(),
+                        type_: FieldType::Named(string_type()),
+                    },
                     GqlObjectField {
                         name: "title".to_string(),
                         type_: FieldType::Named(Ident::new("String", Span::call_site())),
@@ -242,6 +270,8 @@ mod tests {
 
         let result = union.response_for_selection(&context, &selection, &prefix);
 
+        println!("{:?}", result);
+
         assert!(result.is_ok());
 
         assert_eq!(