Add support for default input object values

It is not clear that this is the right approach: we convert the default values from the query to rust literals for the input objects. The default value is then sent twice: in the query string and in the variable.

The reason for using this approach is that Rust structs do not support only setting some fields and not others, so there is no distinction between absent and null fields: there is no way to say if the field in the Variables struct is explicitly set to null or left out (expecting the default value to be used).

Maybe we could generate something other than an Option here, but we would have to figure out how to make this ergonomic.

Author: tomhoule

graphql_query_derive/src/inputs.rs

@@ -125,9 +125,9 @@ mod tests {
             "# [ derive ( Debug , Serialize ) ] ",
             "# [ serde ( rename_all = \"camelCase\" ) ] ",
             "pub struct Cat { ",
-            "offsprings : Vec < Cat > , ",
-            "pawsCount : Float , ",
-            "requirements : Option < CatRequirements > , ",
+            "pub offsprings : Vec < Cat > , ",
+            "pub pawsCount : Float , ",
+            "pub requirements : Option < CatRequirements > , ",
             "}",
         ].into_iter()
             .collect();

graphql_query_derive/src/variables.rs

@@ -2,6 +2,7 @@ use field_type::FieldType;
 use graphql_parser;
 use proc_macro2::{Ident, Span, TokenStream};
 use query::QueryContext;
+use std::collections::BTreeMap;
 
 #[derive(Debug)]
 pub struct Variable {
@@ -16,7 +17,12 @@ impl Variable {
             Some(default) => {
                 let fn_name = Ident::new(&format!("default_{}", self.name), Span::call_site());
                 let ty = self.ty.to_rust(context, "");
-                let value = graphql_parser_value_to_literal(default, self.ty.is_optional());
+                let value = graphql_parser_value_to_literal(
+                    default,
+                    context,
+                    &self.ty,
+                    self.ty.is_optional(),
+                );
                 quote! {
                     pub fn #fn_name() -> #ty {
                         #value
@@ -41,6 +47,8 @@ impl ::std::convert::From<graphql_parser::query::VariableDefinition> for Variabl
 
 fn graphql_parser_value_to_literal(
     value: &graphql_parser::query::Value,
+    context: &QueryContext,
+    ty: &FieldType,
     is_optional: bool,
 ) -> TokenStream {
     use graphql_parser::query::Value;
@@ -63,14 +71,14 @@ fn graphql_parser_value_to_literal(
         Value::List(inner) => {
             let elements = inner
                 .iter()
-                .map(|val| graphql_parser_value_to_literal(val, false));
+                .map(|val| graphql_parser_value_to_literal(val, context, ty, false));
             quote! {
                 vec![
                     #(#elements,)*
                 ]
             }
         }
-        Value::Object(_) => unimplemented!("object literal as default for variable"),
+        Value::Object(obj) => render_object_literal(obj, ty, context),
     };
 
     if is_optional {
@@ -79,3 +87,41 @@ fn graphql_parser_value_to_literal(
         inner
     }
 }
+
+fn render_object_literal(
+    object: &BTreeMap<String, graphql_parser::query::Value>,
+    ty: &FieldType,
+    context: &QueryContext,
+) -> TokenStream {
+    let type_name = ty.inner_name_string();
+    let constructor = Ident::new(&type_name, Span::call_site());
+    let schema_type = context
+        .schema
+        .inputs
+        .get(&type_name)
+        .expect("unknown input type");
+    let fields: Vec<TokenStream> = schema_type
+        .fields
+        .iter()
+        .map(|(name, field)| {
+            let field_name = Ident::new(&name, Span::call_site());
+            let provided_value = object.get(name);
+            match provided_value {
+                Some(default_value) => {
+                    let value = graphql_parser_value_to_literal(
+                        default_value,
+                        context,
+                        &field.type_,
+                        field.type_.is_optional(),
+                    );
+                    quote!(#field_name: #value)
+                }
+                None => quote!(#field_name: None),
+            }
+        })
+        .collect();
+
+    quote!(#constructor {
+        #(#fields,)*
+    })
+}

tests/input_object_variables.rs

@@ -39,10 +39,9 @@ struct DefaultInputObjectVariablesQuery;
 fn input_object_variables_default() {
     let variables = default_input_object_variables_query::Variables {
         msg: default_input_object_variables_query::Variables::default_msg(),
-        reps: default_input_object_variables_query::Variables::default_reps(),
     };
 
     let out = serde_json::to_string(&variables).unwrap();
 
-    assert_eq!(out, r#"{"msg":"o, hai","reps":3}"#);
+    assert_eq!(out, r#"{"msg":{"content":null,"to":{"category":null,"email":"[email protected]","name":null}}}"#);
 }

tests/input_object_variables/input_object_variables_query_defaults.graphql

@@ -1,5 +1,7 @@
-query VariablesQuery($msg: String = "o, hai", $reps: Int = 3) {
-  echo(message: $msg, repetitions: $reps) {
+query VariablesQuery(
+  $msg: Message = { to: { email: "[email protected]" } }
+) {
+  echo(message: $msg) {
     result
   }
 }