Implement default values for scalar variables

Author: tomhoule

graphql_query_derive/src/field_type.rs

@@ -17,7 +17,6 @@ impl FieldType {
     pub fn to_rust(&self, context: &QueryContext, prefix: &str) -> TokenStream {
         match &self {
             FieldType::Named(name) => {
-                let just_the_prefix = Ident::new(prefix, Span::call_site());
                 let name_string = name.to_string();
 
                 let name = if context.schema.scalars.contains(&name_string)
@@ -33,7 +32,7 @@ impl FieldType {
                         Span::call_site(),
                     )
                 } else {
-                    just_the_prefix
+                    Ident::new(prefix, Span::call_site())
                 };
 
                 quote!(#name)
@@ -56,6 +55,13 @@ impl FieldType {
             FieldType::Vector(inner) => inner.inner_name_string(),
         }
     }
+
+    pub fn is_optional(&self) -> bool {
+        match self {
+            FieldType::Optional(_) => true,
+            _ => false,
+        }
+    }
 }
 
 impl ::std::convert::From<graphql_parser::schema::Type> for FieldType {

graphql_query_derive/src/query.rs

@@ -42,16 +42,25 @@ impl QueryContext {
 
         let fields = self.variables.iter().map(|variable| {
             let name = &variable.name;
-            let ty = variable.ty.to_rust(self, name);
+            let ty = variable.ty.to_rust(self, "");
             let name = Ident::new(name, Span::call_site());
             quote!(pub #name: #ty)
         });
 
+        let default_constructors = self
+            .variables
+            .iter()
+            .map(|variable| variable.generate_default_value_constructor(self));
+
         quote! {
             #[derive(Serialize)]
             pub struct Variables {
                 #(#fields,)*
             }
+
+            impl Variables {
+                #(#default_constructors)*
+            }
         }
     }
 

graphql_query_derive/src/variables.rs

@@ -1,5 +1,7 @@
 use field_type::FieldType;
 use graphql_parser;
+use proc_macro2::{Ident, Span, TokenStream};
+use query::QueryContext;
 
 #[derive(Debug)]
 pub struct Variable {
@@ -8,6 +10,25 @@ pub struct Variable {
     pub default: Option<graphql_parser::query::Value>,
 }
 
+impl Variable {
+    pub fn generate_default_value_constructor(&self, context: &QueryContext) -> TokenStream {
+        match &self.default {
+            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());
+                quote! {
+                    pub fn #fn_name() -> #ty {
+                        #value
+                    }
+
+                }
+            }
+            None => quote!(),
+        }
+    }
+}
+
 impl ::std::convert::From<graphql_parser::query::VariableDefinition> for Variable {
     fn from(def: graphql_parser::query::VariableDefinition) -> Variable {
         Variable {
@@ -17,3 +38,44 @@ impl ::std::convert::From<graphql_parser::query::VariableDefinition> for Variabl
         }
     }
 }
+
+fn graphql_parser_value_to_literal(
+    value: &graphql_parser::query::Value,
+    is_optional: bool,
+) -> TokenStream {
+    use graphql_parser::query::Value;
+
+    let inner = match value {
+        Value::Boolean(b) => if *b {
+            quote!(true)
+        } else {
+            quote!(false)
+        },
+        Value::String(s) => quote!(#s.to_string()),
+        Value::Variable(_) => panic!("variable in variable"),
+        Value::Null => panic!("null as default value"),
+        Value::Float(f) => quote!(#f),
+        Value::Int(i) => {
+            let i = i.as_i64();
+            quote!(#i)
+        }
+        Value::Enum(en) => quote!(#en),
+        Value::List(inner) => {
+            let elements = inner
+                .iter()
+                .map(|val| graphql_parser_value_to_literal(val, false));
+            quote! {
+                vec![
+                    #(#elements,)*
+                ]
+            }
+        }
+        Value::Object(_) => unimplemented!("object literal as default for variable"),
+    };
+
+    if is_optional {
+        quote!(Some(#inner))
+    } else {
+        inner
+    }
+}

tests/scalar_variables.rs

@@ -3,6 +3,7 @@ extern crate graphql_client;
 #[macro_use]
 extern crate serde_derive;
 extern crate serde;
+extern crate serde_json;
 
 #[derive(GraphQLQuery)]
 #[GraphQLQuery(
@@ -19,3 +20,23 @@ fn scalar_variables_query_variables_struct() {
         reps: Some(32),
     };
 }
+
+#[derive(GraphQLQuery)]
+#[GraphQLQuery(
+    query_path = "tests/scalar_variables_query_defaults.graphql",
+    schema_path = "tests/scalar_variables_schema.graphql"
+)]
+#[allow(dead_code)]
+struct DefaultScalarVariablesQuery;
+
+#[test]
+fn scalar_variables_default() {
+    let variables = default_scalar_variables_query::Variables {
+        msg: default_scalar_variables_query::Variables::default_msg(),
+        reps: default_scalar_variables_query::Variables::default_reps(),
+    };
+
+    let out = serde_json::to_string(&variables).unwrap();
+
+    assert_eq!(out, r#"{"msg":"o, hai","reps":3}"#);
+}

tests/scalar_variables_query_defaults.graphql

@@ -0,0 +1,5 @@
+query VariablesQuery($msg: String = "o, hai", $reps: Int = 3) {
+  echo(message: $msg, repetitions: $reps) {
+    result
+  }
+}