Merge pull request #116 from mathstuf/only-output-required-structs

Only output required structs

Author: tomhoule

examples/example_module/src/custom_scalars.rs

@@ -1,10 +1,3 @@
-//! We define the custom scalars present in the GitHub schema. More precise types could be provided here (see tests), as long as they are deserializable.
+//! We define the custom scalars present in the GitHub query. More precise types could be provided here (see tests), as long as they are deserializable.
 
-pub type X509Certificate = String;
 pub type URI = String;
-pub type HTML = String;
-pub type GitTimestamp = String;
-pub type GitSSHRemote = String;
-pub type GitObjectID = String;
-pub type Date = String;
-pub type DateTime = String;

examples/github/src/main.rs

@@ -20,14 +20,7 @@ extern crate prettytable;
 use graphql_client::*;
 use structopt::StructOpt;
 
-type X509Certificate = String;
 type URI = String;
-type HTML = String;
-type GitTimestamp = String;
-type GitSSHRemote = String;
-type GitObjectID = String;
-type Date = String;
-type DateTime = String;
 
 #[derive(GraphQLQuery)]
 #[graphql(

examples/github/src/query_1.graphql

@@ -1,5 +1,6 @@
 query RepoView($owner: String!, $name: String!) {
   repository(owner: $owner, name: $name) {
+    homepageUrl
     stargazers {
       totalCount
     }

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,23 +123,39 @@ 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();
 
     Ok(quote! {
+        #[allow(dead_code)]
         type Boolean = bool;
+        #[allow(dead_code)]
         type Float = f64;
+        #[allow(dead_code)]
         type Int = i64;
+        #[allow(dead_code)]
         type ID = String;
 
         #(#scalar_definitions)*

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,