Merge pull request #19 from tomhoule/input-objects

Input objects support

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/field_type.rs

@@ -5,7 +5,7 @@ use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
 use schema::DEFAULT_SCALARS;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Hash)]
 pub enum FieldType {
     Named(Ident),
     Optional(Box<FieldType>),
@@ -15,6 +15,11 @@ pub enum FieldType {
 impl FieldType {
     /// Takes a field type with its name
     pub fn to_rust(&self, context: &QueryContext, prefix: &str) -> TokenStream {
+        let prefix: String = if prefix.is_empty() {
+            self.inner_name_string()
+        } else {
+            prefix.to_string()
+        };
         match &self {
             FieldType::Named(name) => {
                 let name_string = name.to_string();
@@ -32,17 +37,20 @@ impl FieldType {
                         Span::call_site(),
                     )
                 } else {
-                    Ident::new(prefix, Span::call_site())
+                    if prefix.is_empty() {
+                        panic!("Empty prefix for {:?}", self);
+                    }
+                    Ident::new(&prefix, Span::call_site())
                 };
 
                 quote!(#name)
             }
             FieldType::Optional(inner) => {
-                let inner = inner.to_rust(context, prefix);
+                let inner = inner.to_rust(context, &prefix);
                 quote!( Option<#inner>)
             }
             FieldType::Vector(inner) => {
-                let inner = inner.to_rust(context, prefix);
+                let inner = inner.to_rust(context, &prefix);
                 quote!( Vec<#inner>)
             }
         }
@@ -133,6 +141,12 @@ impl ::std::convert::From<introspection_response::FullTypeFieldsType> for FieldT
     }
 }
 
+impl ::std::convert::From<introspection_response::InputValueType> for FieldType {
+    fn from(schema_type: introspection_response::InputValueType) -> FieldType {
+        from_json_type_inner(&schema_type.type_ref, false)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

graphql_query_derive/src/inputs.rs

@@ -1,2 +1,152 @@
+use failure;
+use graphql_parser;
+use introspection_response;
+use objects::GqlObjectField;
+use proc_macro2::{Ident, Span, TokenStream};
+use query::QueryContext;
+use std::collections::HashMap;
+
 #[derive(Debug, PartialEq)]
-pub struct GqlInput;
+pub struct GqlInput {
+    pub name: String,
+    pub fields: HashMap<String, GqlObjectField>,
+}
+
+impl GqlInput {
+    pub 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, "");
+            let name = Ident::new(&field.name, Span::call_site());
+            quote!(pub #name: #ty)
+        });
+
+        Ok(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 {
+        GqlInput {
+            name: schema_input.name,
+            fields: schema_input
+                .fields
+                .into_iter()
+                .map(|field| {
+                    let name = field.name.clone();
+                    let field = GqlObjectField {
+                        name: field.name,
+                        type_: field.value_type.into(),
+                    };
+                    (name, field)
+                })
+                .collect(),
+        }
+    }
+}
+
+impl ::std::convert::From<introspection_response::FullType> for GqlInput {
+    fn from(schema_input: introspection_response::FullType) -> GqlInput {
+        GqlInput {
+            name: schema_input.name.expect("unnamed input object"),
+            fields: schema_input
+                .input_fields
+                .expect("fields on input object")
+                .into_iter()
+                .filter_map(|a| a)
+                .map(|f| {
+                    let name = f.input_value.name.expect("unnamed input object field");
+                    let field = GqlObjectField {
+                        name: name.clone(),
+                        type_: f
+                            .input_value
+                            .type_
+                            .expect("type on input object field")
+                            .into(),
+                    };
+                    (name, field)
+                })
+                .collect(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use constants::*;
+    use field_type::FieldType;
+
+    #[test]
+    fn gql_input_to_rust() {
+        let cat = GqlInput {
+            name: "Cat".to_string(),
+            fields: vec![
+                (
+                    "pawsCount".to_string(),
+                    GqlObjectField {
+                        name: "pawsCount".to_string(),
+                        type_: FieldType::Named(float_type()),
+                    },
+                ),
+                (
+                    "offsprings".to_string(),
+                    GqlObjectField {
+                        name: "offsprings".to_string(),
+                        type_: FieldType::Vector(Box::new(FieldType::Named(Ident::new(
+                            "Cat",
+                            Span::call_site(),
+                        )))),
+                    },
+                ),
+                (
+                    "requirements".to_string(),
+                    GqlObjectField {
+                        name: "requirements".to_string(),
+                        type_: FieldType::Optional(Box::new(FieldType::Named(Ident::new(
+                            "CatRequirements",
+                            Span::call_site(),
+                        )))),
+                    },
+                ),
+            ].into_iter()
+                .collect(),
+        };
+
+        let expected: String = vec![
+            "# [ derive ( Debug , Serialize ) ] ",
+            "# [ serde ( rename_all = \"camelCase\" ) ] ",
+            "pub struct Cat { ",
+            "pub offsprings : Vec < Cat > , ",
+            "pub pawsCount : Float , ",
+            "pub requirements : Option < CatRequirements > , ",
+            "}",
+        ].into_iter()
+            .collect();
+
+        let mut context = QueryContext::new_empty();
+        context.schema.inputs.insert(cat.name.clone(), cat);
+
+        assert_eq!(
+            format!(
+                "{}",
+                context
+                    .schema
+                    .inputs
+                    .get("Cat")
+                    .unwrap()
+                    .to_rust(&context)
+                    .unwrap()
+            ),
+            expected
+        );
+    }
+}

graphql_query_derive/src/introspection_response.rs

@@ -169,7 +169,7 @@ pub struct FullTypeFields {
 #[serde(rename_all = "camelCase")]
 pub struct FullTypeInputFields {
     #[serde(flatten)]
-    input_value: InputValue,
+    pub input_value: InputValue,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -198,11 +198,11 @@ pub struct FullTypePossibleTypes {
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct InputValue {
-    name: Option<String>,
-    description: Option<String>,
+    pub name: Option<String>,
+    pub description: Option<String>,
     #[serde(rename = "type")]
-    type_: Option<InputValueType>,
-    default_value: Option<String>,
+    pub type_: Option<InputValueType>,
+    pub default_value: Option<String>,
 }
 
 #[derive(Clone, Debug, Deserialize)]

graphql_query_derive/src/objects.rs

@@ -14,7 +14,7 @@ pub struct GqlObject {
     pub fields: Vec<GqlObjectField>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Hash)]
 pub struct GqlObjectField {
     pub name: String,
     pub type_: FieldType,

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

@@ -146,20 +146,31 @@ impl Schema {
             .or(context._subscription_root.as_ref())
             .expect("no selection defined");
 
-        use proc_macro2::{Ident, Span};
-
+        // TODO: do something smarter here
         let scalar_definitions = context.schema.scalars.iter().map(|scalar_name| {
+            use proc_macro2::{Ident, Span};
             let ident = Ident::new(scalar_name, Span::call_site());
             quote!(type #ident = String;)
         });
 
+        let input_object_definitions: Result<Vec<TokenStream>, _> = context
+            .schema
+            .inputs
+            .values()
+            .map(|i| i.to_rust(&context))
+            .collect();
+        let input_object_definitions = input_object_definitions?;
+
         Ok(quote! {
             type Boolean = bool;
             type Float = f64;
             type Int = i64;
+            type ID = String;
 
             #(#scalar_definitions)*
 
+            #(#input_object_definitions)*
+
             #(#enum_definitions)*
 
             #(#fragment_definitions)*
@@ -235,7 +246,9 @@ 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 +355,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"),
             }

graphql_query_derive/src/tests/github.rs

@@ -25,7 +25,10 @@ fn ast_from_graphql_and_json_produce_the_same_schema() {
     assert_eq!(json.query_type, gql.query_type);
     assert_eq!(json.mutation_type, gql.mutation_type);
     assert_eq!(json.subscription_type, gql.subscription_type);
-    assert_eq!(json.inputs, gql.inputs);
+    for (json, gql) in json.inputs.iter().zip(gql.inputs.iter()) {
+        assert_eq!(json, gql);
+    }
+    assert_eq!(json.inputs, gql.inputs, "inputs differ");
     for ((json_name, json_value), (gql_name, gql_value)) in json.enums.iter().zip(gql.enums.iter())
     {
         assert_eq!(json_name, gql_name);