Add the implicit __typename field to all objects

It is part of the spec:

https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md

Author: tomhoule

graphql_query_derive/src/constants.rs

@@ -0,0 +1,7 @@
+use proc_macro2::{Ident, Span};
+
+pub const TYPENAME_FIELD: &'static str = "__typename";
+
+pub fn string_type() -> Ident {
+    Ident::new("String", Span::call_site())
+}

graphql_query_derive/src/lib.rs

@@ -16,6 +16,7 @@ extern crate quote;
 
 use proc_macro2::TokenStream;
 
+mod constants;
 mod enums;
 mod field_type;
 mod fragments;

graphql_query_derive/src/objects.rs

@@ -1,10 +1,12 @@
+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 std::borrow::Cow;
 
 #[derive(Debug, PartialEq)]
 pub struct GqlObject {
@@ -19,6 +21,47 @@ pub struct GqlObjectField {
 }
 
 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()),
+            }],
+        }
+    }
+
+    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
+    }
+
+    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")),
+                })
+            });
+
+        item.fields.extend(fields);
+
+        item
+    }
+
     pub fn response_for_selection(
         &self,
         query_context: &QueryContext,
@@ -47,7 +90,6 @@ impl GqlObject {
         selection
             .0
             .iter()
-            .filter(|selected| selected.name() != "__typename")
             .map(|selected| {
                 if let SelectionItem::Field(selected) = selected {
                     let ty = self
@@ -82,6 +124,7 @@ impl GqlObject {
             match item {
                 SelectionItem::Field(f) => {
                     let name = &f.name;
+
                     let ty = &self
                         .fields
                         .iter()

graphql_query_derive/src/schema.rs

@@ -194,17 +194,7 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
 
                         schema.objects.insert(
                             obj.name.clone(),
-                            GqlObject {
-                                name: obj.name.clone(),
-                                fields: obj
-                                    .fields
-                                    .iter()
-                                    .map(|f| GqlObjectField {
-                                        name: f.name.clone(),
-                                        type_: FieldType::from(f.field_type.clone()),
-                                    })
-                                    .collect(),
-                            },
+                            GqlObject::from_graphql_parser_object(obj),
                         );
                     }
                     schema::TypeDefinition::Enum(enm) => {
@@ -325,21 +315,9 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
                             .or_insert_with(|| vec![name.clone()]);
                     }
 
-                    let fields: Vec<GqlObjectField> = ty
-                        .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")),
-                            })
-                        })
-                        .collect();
                     schema
                         .objects
-                        .insert(name.clone(), GqlObject { name, fields });
+                        .insert(name.clone(), GqlObject::from_introspected_schema_json(ty));
                 }
                 Some(__TypeKind::INTERFACE) => {
                     let iface = GqlInterface {
@@ -372,6 +350,7 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
 
 #[cfg(test)]
 mod tests {
+    use constants::*;
     use super::*;
     use proc_macro2::{Ident, Span};
 
@@ -385,6 +364,10 @@ mod tests {
             Some(&GqlObject {
                 name: "Droid".to_string(),
                 fields: vec![
+                    GqlObjectField {
+                        name: TYPENAME_FIELD.to_string(),
+                        type_: FieldType::Named(string_type()),
+                    },
                     GqlObjectField {
                         name: "id".to_string(),
                         type_: FieldType::Optional(Box::new(FieldType::Named(Ident::new(