WIP - input objects

Author: tomhoule

graphql_query_derive/src/constants.rs

@@ -5,3 +5,7 @@ pub const TYPENAME_FIELD: &'static str = "__typename";
 pub fn string_type() -> Ident {
     Ident::new("String", Span::call_site())
 }
+
+pub fn float_type() -> Ident {
+    Ident::new("Float", Span::call_site())
+}

graphql_query_derive/src/inputs.rs

@@ -1,2 +1,78 @@
+use query::QueryContext;
+use objects::GqlObjectField;
+use proc_macro2::{Ident, Span, TokenStream};
+use introspection_response;
+use graphql_parser;
+
 #[derive(Debug, PartialEq)]
-pub struct GqlInput;
+pub struct GqlInput {
+    pub name: String,
+    pub fields: Vec<GqlObjectField>,
+}
+
+impl GqlInput {
+    pub fn to_rust(&self, context: &QueryContext) -> TokenStream {
+        let name = Ident::new(&self.name, Span::call_site());
+        let fields = self.fields.iter().map(|field| {
+            let ty = field.type_.to_rust(&context, "");
+            let name = Ident::new(&field.name, Span::call_site());
+            quote!(#ty: #name)
+        });
+
+        quote!{
+            #[derive(Debug, Serialize)]
+            #[serde(rename_all = "camelCase")]
+            pub struct #name {
+                #(#fields,)*
+            }
+        }
+    }
+}
+
+impl ::std::convert::From<graphql_parser::schema::InputObjectType> for GqlInput {
+    fn from(schema_input: graphql_parser::schema::InputObjectType) -> GqlInput {
+        unimplemented!();
+    }
+}
+
+impl ::std::convert::From<introspection_response::FullType> for GqlInput {
+    fn from(schema_input: introspection_response::FullType) -> GqlInput {
+        unimplemented!();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use constants::*;
+    use field_type::FieldType;
+
+    #[test]
+    fn gql_input_to_rust() {
+        let input = GqlInput {
+            name: "Cat".to_string(),
+            fields: vec![
+                GqlObjectField {
+                    name: "pawsCount".to_string(),
+                    type_: FieldType::Named(float_type())
+                },
+                GqlObjectField {
+                    name: "offsprings".to_string(),
+                    type_: FieldType::Vector(Box::new(FieldType::Named(Ident::new("Cat", Span::call_site())))),
+                },
+                GqlObjectField {
+                    name: "requirements".to_string(),
+                    type_: FieldType::Optional(Box::new(FieldType::Named(Ident::new("CatRequirements", Span::call_site())))),
+                },
+            ],
+        };
+
+
+        let expected: String = vec![
+            "",
+            "",
+        ].into_iter().collect();
+
+        assert_eq!(format!("{:?}", input.to_rust()), expected);
+    }
+}

graphql_query_derive/src/query.rs

@@ -7,6 +7,7 @@ use selection::Selection;
 use std::collections::BTreeMap;
 use variables::Variable;
 
+/// This holds all the information we need during the code generation phase.
 pub struct QueryContext {
     pub _subscription_root: Option<Vec<TokenStream>>,
     pub fragments: BTreeMap<String, GqlFragment>,
@@ -17,6 +18,7 @@ pub struct QueryContext {
 }
 
 impl QueryContext {
+    /// Create a QueryContext with the given Schema.
     pub fn new(schema: Schema) -> QueryContext {
         QueryContext {
             _subscription_root: None,
@@ -28,12 +30,14 @@ impl QueryContext {
         }
     }
 
+    /// Ingest the variable definitions for the query we are generating code for.
     pub fn register_variables(&mut self, variables: &[graphql_parser::query::VariableDefinition]) {
         variables.iter().for_each(|variable| {
             self.variables.push(variable.clone().into());
         });
     }
 
+    /// Generate the Variables struct and all the necessary supporting code.
     pub fn expand_variables(&self) -> TokenStream {
         if self.variables.is_empty() {
             return quote!(#[derive(Serialize)]

graphql_query_derive/src/schema.rs

@@ -235,7 +235,7 @@ impl ::std::convert::From<graphql_parser::schema::Document> for Schema {
                         );
                     }
                     schema::TypeDefinition::InputObject(input) => {
-                        schema.inputs.insert(input.name, GqlInput);
+                        schema.inputs.insert(input.name.clone(), GqlInput::from(input));
                     }
                 },
                 schema::Definition::DirectiveDefinition(_) => (),
@@ -342,7 +342,7 @@ impl ::std::convert::From<::introspection_response::IntrospectionResponse> for S
                     schema.interfaces.insert(name, iface);
                 }
                 Some(__TypeKind::INPUT_OBJECT) => {
-                    schema.inputs.insert(name, GqlInput);
+                    schema.inputs.insert(name, GqlInput::from(ty.clone()));
                 }
                 _ => unimplemented!("unimplemented definition"),
             }