graphql_query_derive: only output required structures

This can help to massively reduce compile times.

Fixes #114.

Author: mathstuf

graphql_client_codegen/src/codegen.rs

@@ -37,6 +37,7 @@ pub fn response_for_query(
                         name: fragment.name,
                         selection: Selection::from(&fragment.selection_set),
                         on,
+                        is_required: false.into(),
                     },
                 );
             }
@@ -97,11 +98,23 @@ pub fn response_for_query(
         .schema
         .enums
         .values()
-        .map(|enm| enm.to_rust(&context));
+        .filter_map(|enm| {
+            if enm.is_required.get() {
+                Some(enm.to_rust(&context))
+            } else {
+                None
+            }
+        });
     let fragment_definitions: Result<Vec<TokenStream>, _> = context
         .fragments
         .values()
-        .map(|fragment| fragment.to_rust(&context))
+        .filter_map(|fragment| {
+            if fragment.is_required.get() {
+                Some(fragment.to_rust(&context))
+            } else {
+                None
+            }
+        })
         .collect();
     let fragment_definitions = fragment_definitions?;
     let variables_struct = operation.expand_variables(&context);
@@ -110,15 +123,27 @@ pub fn response_for_query(
         .schema
         .inputs
         .values()
-        .map(|i| i.to_rust(&context))
+        .filter_map(|i| {
+            if i.is_required.get() {
+                Some(i.to_rust(&context))
+            } else {
+                None
+            }
+        })
         .collect();
     let input_object_definitions = input_object_definitions?;
 
     let scalar_definitions: Vec<TokenStream> = context
         .schema
         .scalars
         .values()
-        .map(|s| s.to_rust())
+        .filter_map(|s| {
+            if s.is_required.get() {
+                Some(s.to_rust())
+            } else {
+                None
+            }
+        })
         .collect();
 
     let response_derives = context.response_derives();

graphql_client_codegen/src/enums.rs

@@ -1,4 +1,5 @@
 use proc_macro2::{Ident, Span, TokenStream};
+use std::cell::Cell;
 
 pub const ENUMS_PREFIX: &str = "";
 
@@ -13,6 +14,7 @@ pub struct GqlEnum {
     pub description: Option<String>,
     pub name: String,
     pub variants: Vec<EnumVariant>,
+    pub is_required: Cell<bool>,
 }
 
 impl GqlEnum {

graphql_client_codegen/src/field_type.rs

@@ -22,12 +22,12 @@ impl FieldType {
         };
         match &self {
             FieldType::Named(ref name) => {
-                let full_name = if context.schema.scalars.contains_key(name) || DEFAULT_SCALARS
+                let full_name = if context.schema.scalars.get(name).map(|s| s.is_required.set(true)).is_some() || DEFAULT_SCALARS
                     .iter()
                     .any(|elem| elem == name)
                 {
                     name.clone()
-                } else if context.schema.enums.contains_key(name) {
+                } else if context.schema.enums.get(name).map(|enm| enm.is_required.set(true)).is_some() {
                     format!("{}{}", ENUMS_PREFIX, name)
                 } else {
                     if prefix.is_empty() {

graphql_client_codegen/src/fragments.rs

@@ -1,12 +1,14 @@
 use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
 use selection::Selection;
+use std::cell::Cell;
 
 #[derive(Debug, PartialEq)]
 pub struct GqlFragment {
     pub name: String,
     pub on: String,
     pub selection: Selection,
+    pub is_required: Cell<bool>,
 }
 
 impl GqlFragment {

graphql_client_codegen/src/inputs.rs

@@ -6,23 +6,39 @@ use introspection_response;
 use objects::GqlObjectField;
 use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
+use schema::Schema;
 use std::collections::HashMap;
+use std::cell::Cell;
 
 /// Represents an input object type from a GraphQL schema
 #[derive(Debug, Clone, PartialEq)]
 pub struct GqlInput {
     pub description: Option<String>,
     pub name: String,
     pub fields: HashMap<String, GqlObjectField>,
+    pub is_required: Cell<bool>,
 }
 
 impl GqlInput {
+    pub(crate) fn require(&self, schema: &Schema) {
+        if self.is_required.get() {
+            return;
+        }
+        self.is_required.set(true);
+        self.fields
+            .values()
+            .for_each(|field| {
+                schema.require(&field.type_.inner_name_string());
+            })
+    }
+
     pub(crate) fn to_rust(&self, context: &QueryContext) -> Result<TokenStream, failure::Error> {
         let name = Ident::new(&self.name, Span::call_site());
         let mut fields: Vec<&GqlObjectField> = self.fields.values().collect();
         fields.sort_unstable_by(|a, b| a.name.cmp(&b.name));
         let fields = fields.iter().map(|field| {
             let ty = field.type_.to_rust(&context, "");
+            context.schema.require(&field.type_.inner_name_string());
             let original_name = &field.name;
             let snake_case_name = field.name.to_snake_case();
             let rename = ::shared::field_rename_annotation(&original_name, &snake_case_name);
@@ -59,6 +75,7 @@ impl ::std::convert::From<graphql_parser::schema::InputObjectType> for GqlInput
                     };
                     (name, field)
                 }).collect(),
+            is_required: false.into(),
         }
     }
 }
@@ -87,6 +104,7 @@ impl ::std::convert::From<introspection_response::FullType> for GqlInput {
                     };
                     (name, field)
                 }).collect(),
+            is_required: false.into(),
         }
     }
 }
@@ -132,6 +150,7 @@ mod tests {
                 ),
             ].into_iter()
             .collect(),
+            is_required: false.into(),
         };
 
         let expected: String = vec![

graphql_client_codegen/src/interfaces.rs

@@ -5,6 +5,7 @@ use query::QueryContext;
 use selection::{Selection, SelectionItem};
 use shared::*;
 use std::borrow::Cow;
+use std::cell::Cell;
 use std::collections::HashSet;
 use unions::union_variants;
 
@@ -14,6 +15,7 @@ pub struct GqlInterface {
     pub implemented_by: HashSet<String>,
     pub name: String,
     pub fields: Vec<GqlObjectField>,
+    pub is_required: Cell<bool>,
 }
 
 impl GqlInterface {
@@ -23,6 +25,7 @@ impl GqlInterface {
             name: name.into_owned(),
             implemented_by: HashSet::new(),
             fields: vec![],
+            is_required: false.into(),
         }
     }
 

graphql_client_codegen/src/objects.rs

@@ -5,15 +5,18 @@ use field_type::FieldType;
 use graphql_parser::schema;
 use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
+use schema::Schema;
 use selection::*;
 use shared::{field_impls_for_selection, response_fields_for_selection};
 use std::borrow::Cow;
+use std::cell::Cell;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct GqlObject {
     pub description: Option<String>,
     pub fields: Vec<GqlObjectField>,
     pub name: String,
+    pub is_required: Cell<bool>,
 }
 
 #[derive(Clone, Debug, PartialEq, Hash)]
@@ -60,6 +63,7 @@ impl GqlObject {
             description: description.map(|s| s.to_owned()),
             name: name.into_owned(),
             fields: vec![typename_field()],
+            is_required: false.into(),
         }
     }
 
@@ -105,6 +109,18 @@ impl GqlObject {
         item
     }
 
+    pub(crate) fn require(&self, schema: &Schema) {
+        if self.is_required.get() {
+            return;
+        }
+        self.is_required.set(true);
+        self.fields
+            .iter()
+            .for_each(|field| {
+                schema.require(&field.type_.inner_name_string());
+            })
+    }
+
     pub(crate) fn response_for_selection(
         &self,
         query_context: &QueryContext,

graphql_client_codegen/src/query.rs

@@ -33,6 +33,12 @@ impl QueryContext {
         }
     }
 
+    pub(crate) fn require(&self, typename_: &str) {
+        self.fragments
+            .get(typename_)
+            .map(|fragment| fragment.is_required.set(true));
+    }
+
     /// For testing only. creates an empty QueryContext with an empty Schema.
     #[cfg(test)]
     pub(crate) fn new_empty() -> QueryContext {
@@ -52,13 +58,17 @@ impl QueryContext {
         selection: &Selection,
         prefix: &str,
     ) -> Result<TokenStream, failure::Error> {
-        if let Some(_enm) = self.schema.enums.get(ty) {
+        if let Some(enm) = self.schema.enums.get(ty) {
+            enm.is_required.set(true);
             Ok(quote!()) // we already expand enums separately
         } else if let Some(obj) = self.schema.objects.get(ty) {
+            obj.is_required.set(true);
             obj.response_for_selection(self, &selection, prefix)
         } else if let Some(iface) = self.schema.interfaces.get(ty) {
+            iface.is_required.set(true);
             iface.response_for_selection(self, &selection, prefix)
         } else if let Some(unn) = self.schema.unions.get(ty) {
+            unn.is_required.set(true);
             unn.response_for_selection(self, &selection, prefix)
         } else {
             Ok(quote!())

graphql_client_codegen/src/scalars.rs

@@ -1,9 +1,11 @@
 use proc_macro2;
+use std::cell::Cell;
 
 #[derive(Debug, Clone, PartialEq, PartialOrd, Ord, Eq)]
 pub struct Scalar {
     pub name: String,
     pub description: Option<String>,
+    pub is_required: Cell<bool>,
 }
 
 impl Scalar {

graphql_client_codegen/src/schema.rs

@@ -55,6 +55,28 @@ impl Schema {
                 Ok(())
             }).collect()
     }
+
+    pub(crate) fn require(&self, typename_: &str) {
+        DEFAULT_SCALARS.iter()
+            .find(|&&s| s == typename_)
+            .map(|_| ())
+            .or_else(|| {
+                self.enums.get(typename_)
+                    .map(|enm| enm.is_required.set(true))
+            })
+            .or_else(|| {
+                self.inputs.get(typename_)
+                    .map(|input| input.require(self))
+            })
+            .or_else(|| {
+                self.objects.get(typename_)
+                    .map(|object| object.require(self))
+            })
+            .or_else(|| {
+                self.scalars.get(typename_)
+                    .map(|scalar| scalar.is_required.set(true))
+            });
+    }
 }
 
 impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
@@ -94,6 +116,7 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
                                         description: v.description.clone(),
                                         name: v.name.clone(),
                                     }).collect(),
+                                is_required: false.into(),
                             },
                         );
                     }
@@ -103,6 +126,7 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
                             Scalar {
                                 name: scalar.name,
                                 description: scalar.description,
+                                is_required: false.into(),
                             },
                         );
                     }
@@ -113,6 +137,7 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
                             GqlUnion {
                                 variants,
                                 description: union.description,
+                                is_required: false.into(),
                             },
                         );
                     }
@@ -196,6 +221,7 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
                         name: name.clone(),
                         description: ty.description.clone(),
                         variants,
+                        is_required: false.into(),
                     };
                     schema.enums.insert(name, enm);
                 }
@@ -210,6 +236,7 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
                             Scalar {
                                 name,
                                 description: ty.description.as_ref().map(|d| d.clone()),
+                                is_required: false.into(),
                             },
                         );
                     }
@@ -227,6 +254,7 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
                         GqlUnion {
                             description: ty.description.as_ref().map(|d| d.to_owned()),
                             variants,
+                            is_required: false.into(),
                         },
                     );
                 }
@@ -347,6 +375,7 @@ mod tests {
                         deprecation: DeprecationStatus::Current,
                     },
                 ],
+                is_required: false.into(),
             })
         )
     }