Merge pull request #14 from zaeleus/variables-type-alias

Add type alias for query variables

Author: mhallin

benches/bench.rs

@@ -3,9 +3,7 @@ extern crate juniper;
 
 use bencher::Bencher;
 
-use std::collections::{HashMap};
-
-use juniper::{execute, RootNode, EmptyMutation};
+use juniper::{execute, RootNode, EmptyMutation, Variables};
 use juniper::tests::model::Database;
 
 fn query_type_name(b: &mut Bencher) {
@@ -21,7 +19,7 @@ fn query_type_name(b: &mut Bencher) {
           }
         }"#;
 
-    b.iter(|| execute(doc, None, &schema, &HashMap::new(), &database));
+    b.iter(|| execute(doc, None, &schema, &Variables::new(), &database));
 }
 
 fn introspection_query(b: &mut Bencher) {
@@ -122,7 +120,7 @@ fn introspection_query(b: &mut Bencher) {
   }
 "#;
 
-    b.iter(|| execute(doc, None, &schema, &HashMap::new(), &database));
+    b.iter(|| execute(doc, None, &schema, &Variables::new(), &database));
 }
 
 benchmark_group!(queries, query_type_name, introspection_query);

src/ast.rs

@@ -4,6 +4,7 @@ use std::hash::Hash;
 use std::vec;
 use std::slice;
 
+use executor::Variables;
 use parser::Spanning;
 
 /// A type literal in the syntax tree
@@ -265,7 +266,7 @@ impl InputValue {
     }
 
     /// Resolve all variables to their values.
-    pub fn into_const(self, vars: &HashMap<String, InputValue>) -> InputValue {
+    pub fn into_const(self, vars: &Variables) -> InputValue {
         match self {
             InputValue::Variable(v) => vars.get(&v)
                 .map_or_else(InputValue::null, Clone::clone),

src/executor.rs

@@ -36,7 +36,7 @@ pub enum FieldPath<'a> {
 /// of the current field stack, context, variables, and errors.
 pub struct Executor<'a, CtxT> where CtxT: 'a {
     fragments: &'a HashMap<&'a str, &'a Fragment<'a>>,
-    variables: &'a HashMap<String, InputValue>,
+    variables: &'a Variables,
     current_selection_set: Option<&'a [Selection<'a>]>,
     schema: &'a SchemaType<'a>,
     context: &'a CtxT,
@@ -61,6 +61,9 @@ pub type FieldResult<T> = Result<T, String>;
 /// The result of resolving an unspecified field
 pub type ExecutionResult = Result<Value, String>;
 
+/// The map of variables used for substitution during query execution
+pub type Variables = HashMap<String, InputValue>;
+
 #[doc(hidden)]
 pub trait IntoResolvable<'a, T: GraphQLType, C>: Sized {
     #[doc(hidden)]
@@ -221,7 +224,7 @@ impl<'a, CtxT> Executor<'a, CtxT> {
     }
 
     #[doc(hidden)]
-    pub fn variables(&self) -> &'a HashMap<String, InputValue> {
+    pub fn variables(&self) -> &'a Variables {
         self.variables
     }
 
@@ -294,7 +297,7 @@ pub fn execute_validated_query<'a, QueryT, MutationT, CtxT>(
     document: Document,
     operation_name: Option<&str>,
     root_node: &RootNode<QueryT, MutationT>,
-    variables: &HashMap<String, InputValue>,
+    variables: &Variables,
     context: &CtxT
 )
     -> Result<(Value, Vec<ExecutionError>), GraphQLError<'a>>

src/executor_tests/directives.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use value::Value;
 use ast::InputValue;
+use executor::Variables;
 use schema::model::RootNode;
 use types::scalars::EmptyMutation;
 
@@ -17,7 +18,7 @@ graphql_object!(TestType: () |&self| {
     }
 });
 
-fn run_variable_query<F>(query: &str, vars: HashMap<String, InputValue>, f: F)
+fn run_variable_query<F>(query: &str, vars: Variables, f: F)
     where F: Fn(&HashMap<String, Value>) -> ()
 {
     let schema = RootNode::new(TestType, EmptyMutation::<()>::new());
@@ -37,7 +38,7 @@ fn run_variable_query<F>(query: &str, vars: HashMap<String, InputValue>, f: F)
 fn run_query<F>(query: &str, f: F)
     where F: Fn(&HashMap<String, Value>) -> ()
 {
-    run_variable_query(query, HashMap::new(), f);
+    run_variable_query(query, Variables::new(), f);
 }
 
 #[test]

src/executor_tests/enums.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use value::Value;
 use ast::InputValue;
+use executor::Variables;
 use schema::model::RootNode;
 use ::GraphQLError::ValidationError;
 use validation::RuleError;
@@ -28,7 +29,7 @@ graphql_object!(TestType: () |&self| {
     }
 });
 
-fn run_variable_query<F>(query: &str, vars: HashMap<String, InputValue>, f: F)
+fn run_variable_query<F>(query: &str, vars: Variables, f: F)
     where F: Fn(&HashMap<String, Value>) -> ()
 {
     let schema = RootNode::new(TestType, EmptyMutation::<()>::new());
@@ -48,7 +49,7 @@ fn run_variable_query<F>(query: &str, vars: HashMap<String, InputValue>, f: F)
 fn run_query<F>(query: &str, f: F)
     where F: Fn(&HashMap<String, Value>) -> ()
 {
-    run_variable_query(query, HashMap::new(), f);
+    run_variable_query(query, Variables::new(), f);
 }
 
 #[test]

src/executor_tests/introspection.rs

@@ -1,5 +1,4 @@
-use std::collections::HashMap;
-
+use executor::Variables;
 use value::Value;
 use schema::model::RootNode;
 use types::scalars::EmptyMutation;
@@ -70,7 +69,7 @@ fn test_execution() {
     "#;
     let schema = RootNode::new(Root {}, EmptyMutation::<()>::new());
 
-    let (result, errs) = ::execute(doc, None, &schema, &HashMap::new(), &())
+    let (result, errs) = ::execute(doc, None, &schema, &Variables::new(), &())
         .expect("Execution failed");
 
     assert_eq!(errs, []);
@@ -107,7 +106,7 @@ fn enum_introspection() {
     "#;
     let schema = RootNode::new(Root {}, EmptyMutation::<()>::new());
 
-    let (result, errs) = ::execute(doc, None, &schema, &HashMap::new(), &())
+    let (result, errs) = ::execute(doc, None, &schema, &Variables::new(), &())
         .expect("Execution failed");
 
     assert_eq!(errs, []);
@@ -185,7 +184,7 @@ fn interface_introspection() {
     "#;
     let schema = RootNode::new(Root {}, EmptyMutation::<()>::new());
 
-    let (result, errs) = ::execute(doc, None, &schema, &HashMap::new(), &())
+    let (result, errs) = ::execute(doc, None, &schema, &Variables::new(), &())
         .expect("Execution failed");
 
     assert_eq!(errs, []);
@@ -286,7 +285,7 @@ fn object_introspection() {
     "#;
     let schema = RootNode::new(Root {}, EmptyMutation::<()>::new());
 
-    let (result, errs) = ::execute(doc, None, &schema, &HashMap::new(), &())
+    let (result, errs) = ::execute(doc, None, &schema, &Variables::new(), &())
         .expect("Execution failed");
 
     assert_eq!(errs, []);
@@ -398,7 +397,7 @@ fn scalar_introspection() {
     "#;
     let schema = RootNode::new(Root {}, EmptyMutation::<()>::new());
 
-    let (result, errs) = ::execute(doc, None, &schema, &HashMap::new(), &())
+    let (result, errs) = ::execute(doc, None, &schema, &Variables::new(), &())
         .expect("Execution failed");
 
     assert_eq!(errs, []);

src/executor_tests/variables.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use value::Value;
 use ast::InputValue;
+use executor::Variables;
 use schema::model::RootNode;
 use ::GraphQLError::ValidationError;
 use validation::RuleError;
@@ -86,7 +87,7 @@ graphql_object!(TestType: () |&self| {
     }
 });
 
-fn run_variable_query<F>(query: &str, vars: HashMap<String, InputValue>, f: F)
+fn run_variable_query<F>(query: &str, vars: Variables, f: F)
     where F: Fn(&HashMap<String, Value>) -> ()
 {
     let schema = RootNode::new(TestType, EmptyMutation::<()>::new());
@@ -106,7 +107,7 @@ fn run_variable_query<F>(query: &str, vars: HashMap<String, InputValue>, f: F)
 fn run_query<F>(query: &str, f: F)
     where F: Fn(&HashMap<String, Value>) -> ()
 {
-    run_variable_query(query, HashMap::new(), f);
+    run_variable_query(query, Variables::new(), f);
 }
 
 #[test]

src/integrations/iron_handlers.rs

@@ -6,11 +6,11 @@ use iron::mime::Mime;
 use iron::status;
 use iron::method;
 
-use std::collections::{HashMap, BTreeMap};
+use std::collections::BTreeMap;
 
 use rustc_serialize::json::{ToJson, Json};
 
-use ::{InputValue, GraphQLType, RootNode, execute};
+use ::{InputValue, GraphQLType, RootNode, Variables, execute};
 
 /// Handler that executes GraphQL queries in the given schema
 ///
@@ -62,7 +62,7 @@ impl<'a, CtxFactory, Query, Mutation, CtxT>
         let url = req.url.clone().into_generic_url();
 
         let mut query = None;
-        let variables = HashMap::new();
+        let variables = Variables::new();
 
         for (k, v) in url.query_pairs() {
             if k == "query" {
@@ -84,17 +84,16 @@ impl<'a, CtxFactory, Query, Mutation, CtxT>
         };
 
         let mut query = None;
-        let mut variables = HashMap::new();
+        let mut variables = Variables::new();
 
         for (k, v) in json_obj.into_iter() {
             if k == "query" {
                 query = v.as_string().map(|s| s.to_owned());
             }
             else if k == "variables" {
-                variables = match InputValue::from_json(v).to_object_value() {
-                    Some(o) => o.into_iter().map(|(k, v)| (k.to_owned(), v.clone())).collect(),
-                    _ => HashMap::new(),
-                };
+                variables = InputValue::from_json(v).to_object_value()
+                    .map(|o| o.into_iter().map(|(k, v)| (k.to_owned(), v.clone())).collect())
+                    .unwrap_or_default();
             }
         }
 
@@ -103,7 +102,7 @@ impl<'a, CtxFactory, Query, Mutation, CtxT>
         self.execute(req, &query, &variables)
     }
 
-    fn execute(&self, req: &mut Request, query: &str, variables: &HashMap<String, InputValue>) -> IronResult<Response> {
+    fn execute(&self, req: &mut Request, query: &str, variables: &Variables) -> IronResult<Response> {
         let context = (self.context_factory)(req);
         let result = execute(query, None, &self.root_node, variables, &context);
 

src/lib.rs

@@ -209,8 +209,6 @@ mod integrations;
 
 #[cfg(test)] mod executor_tests;
 
-use std::collections::HashMap;
-
 use parser::{parse_document_source, ParseError, Spanning};
 use validation::{ValidatorContext, visit_all_rules, validate_input_values};
 use executor::execute_validated_query;
@@ -219,8 +217,9 @@ pub use ast::{ToInputValue, FromInputValue, InputValue, Type, Selection};
 pub use value::Value;
 pub use types::base::{Arguments, GraphQLType, TypeKind};
 pub use executor::{
-    Context, FromContext,
-    Executor, Registry, ExecutionResult, ExecutionError, FieldResult, IntoResolvable,
+    Executor, ExecutionError, Registry,
+    Context, FromContext, IntoResolvable,
+    FieldResult, ExecutionResult, Variables,
 };
 pub use validation::RuleError;
 pub use types::scalars::{EmptyMutation, ID};
@@ -247,7 +246,7 @@ pub fn execute<'a, CtxT, QueryT, MutationT>(
     document_source: &'a str,
     operation_name: Option<&str>,
     root_node: &RootNode<QueryT, MutationT>,
-    variables: &HashMap<String, InputValue>,
+    variables: &Variables,
     context: &CtxT,
 )
     -> Result<(Value, Vec<ExecutionError>), GraphQLError<'a>>

src/macros/tests/args.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 
+use executor::Variables;
 use value::Value;
 use schema::model::RootNode;
 use types::scalars::EmptyMutation;
@@ -90,7 +91,7 @@ fn run_args_info_query<F>(field_name: &str, f: F)
     "#;
     let schema = RootNode::new(Root {}, EmptyMutation::<()>::new());
 
-    let (result, errs) = ::execute(doc, None, &schema, &HashMap::new(), &())
+    let (result, errs) = ::execute(doc, None, &schema, &Variables::new(), &())
         .expect("Execution failed");
 
     assert_eq!(errs, []);