Pass the executor immutably through resolution

The executor is now using internal mutability through RwLock to make
it thread-safe.

Author: mhallin

src/executor.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 use std::marker::PhantomData;
+use std::sync::RwLock;
 
 use ::GraphQLError;
 use ast::{InputValue, ToInputValue, Document, Selection, Fragment, Definition, Type, FromInputValue, OperationType};
@@ -41,7 +42,7 @@ pub struct Executor<'a, CtxT> where CtxT: 'a {
     current_selection_set: Option<Vec<Selection>>,
     schema: &'a SchemaType,
     context: &'a CtxT,
-    errors: &'a mut Vec<ExecutionError>,
+    errors: &'a RwLock<Vec<ExecutionError>>,
     field_path: FieldPath<'a>,
 }
 
@@ -81,7 +82,7 @@ impl<T> IntoFieldResult<T> for FieldResult<T> {
 
 impl<'a, CtxT> Executor<'a, CtxT> {
     /// Resolve a single arbitrary value into an `ExecutionResult`
-    pub fn resolve<T: GraphQLType<CtxT>>(&mut self, value: &T) -> ExecutionResult {
+    pub fn resolve<T: GraphQLType<CtxT>>(&self, value: &T) -> ExecutionResult {
         Ok(value.resolve(
             match self.current_selection_set {
                 Some(ref sel) => Some(sel.clone()),
@@ -93,7 +94,7 @@ impl<'a, CtxT> Executor<'a, CtxT> {
     /// Resolve a single arbitrary value into a return value
     ///
     /// If the field fails to resolve, `null` will be returned.
-    pub fn resolve_into_value<T: GraphQLType<CtxT>>(&mut self, value: &T) -> Value {
+    pub fn resolve_into_value<T: GraphQLType<CtxT>>(&self, value: &T) -> Value {
         match self.resolve(value) {
             Ok(v) => v,
             Err(e) => {
@@ -108,7 +109,7 @@ impl<'a, CtxT> Executor<'a, CtxT> {
     ///
     /// This can be used to connect different types, e.g. from different Rust
     /// libraries, that require different context types.
-    pub fn replaced_context<'b, NewCtxT>(&'b mut self, ctx: &'b NewCtxT) -> Executor<'b, NewCtxT> {
+    pub fn replaced_context<'b, NewCtxT>(&'b self, ctx: &'b NewCtxT) -> Executor<'b, NewCtxT> {
         Executor {
             fragments: self.fragments,
             variables: self.variables,
@@ -122,7 +123,7 @@ impl<'a, CtxT> Executor<'a, CtxT> {
 
     #[doc(hidden)]
     pub fn sub_executor(
-        &mut self,
+        &self,
         field_name: Option<String>,
         location: SourcePosition,
         selection_set: Option<Vec<Selection>>,
@@ -167,11 +168,13 @@ impl<'a, CtxT> Executor<'a, CtxT> {
     }
 
     /// Add an error to the execution engine
-    pub fn push_error(&mut self, error: String, location: SourcePosition) {
+    pub fn push_error(&self, error: String, location: SourcePosition) {
         let mut path = Vec::new();
         self.field_path.construct_path(&mut path);
 
-        self.errors.push(ExecutionError {
+        let mut errors = self.errors.write().unwrap();
+
+        errors.push(ExecutionError {
             location: location,
             path: path,
             message: error,
@@ -261,17 +264,17 @@ pub fn execute_validated_query<'a, QueryT, MutationT, CtxT>(
         None => return Err(GraphQLError::UnknownOperationName),
     };
 
-    let mut errors = Vec::new();
+    let errors = RwLock::new(Vec::new());
     let value;
 
     {
-        let mut executor = Executor {
+        let executor = Executor {
             fragments: &fragments.into_iter().map(|f| (f.item.name.item.clone(), f.item)).collect(),
             variables: variables,
             current_selection_set: Some(op.item.selection_set),
             schema: &root_node.schema,
             context: context,
-            errors: &mut errors,
+            errors: &errors,
             field_path: FieldPath::Root(op.start),
         };
 
@@ -281,6 +284,7 @@ pub fn execute_validated_query<'a, QueryT, MutationT, CtxT>(
         };
     }
 
+    let mut errors = errors.into_inner().unwrap();
     errors.sort();
 
     Ok((value, errors))

src/executor_tests/executor.rs

@@ -167,7 +167,7 @@ mod threads_context_correctly {
     struct Schema;
 
     graphql_object!(Schema: String |&self| {
-        field a(&mut executor) -> String { executor.context().clone() }
+        field a(&executor) -> String { executor.context().clone() }
     });
 
     #[test]

src/lib.rs

@@ -67,7 +67,7 @@ graphql_object!(User: Database |&self| {
     //
     // In this example, the context is used to convert the friend_ids array
     // into actual User objects.
-    field friends(&mut executor) -> Vec<&User> {
+    field friends(&executor) -> Vec<&User> {
         self.friend_ids.iter()
             .filter_map(|id| executor.context().users.get(id))
             .collect()
@@ -79,7 +79,7 @@ graphql_object!(User: Database |&self| {
 graphql_object!(QueryRoot: Database |&self| {
 
     // Arguments work just like they do on functions.
-    field user(&mut executor, id: String) -> Option<&User> {
+    field user(&executor, id: String) -> Option<&User> {
         executor.context().users.get(&id)
     }
 });
@@ -121,15 +121,15 @@ use juniper::iron_handlers::GraphQLHandler;
 #         Ok(&self.name)
 #     }
 #
-#     field friends(&mut executor) -> FieldResult<Vec<&User>> {
+#     field friends(&executor) -> FieldResult<Vec<&User>> {
 #         Ok(self.friend_ids.iter()
 #             .filter_map(|id| executor.context().users.get(id))
 #             .collect())
 #     }
 # });
 #
 # graphql_object!(QueryRoot: Database |&self| {
-#     field user(&mut executor, id: String) -> FieldResult<Option<&User>> {
+#     field user(&executor, id: String) -> FieldResult<Option<&User>> {
 #         Ok(executor.context().users.get(&id))
 #     }
 # });

src/macros/args.rs

@@ -15,9 +15,9 @@ macro_rules! __graphql__args {
 
     (
         @assign_arg_vars,
-        $args:ident, $executorvar:ident, &mut $exec:ident $($rest:tt)*
+        $args:ident, $executorvar:ident, &$exec:ident $($rest:tt)*
     ) => {
-        let __graphql__args!(@as_pattern, $exec) = &mut $executorvar;
+        let __graphql__args!(@as_pattern, $exec) = &$executorvar;
         __graphql__args!(@assign_arg_vars, $args, $executorvar, $($rest)*);
     };
 
@@ -59,7 +59,7 @@ macro_rules! __graphql__args {
 
     (
         @apply_args,
-        $reg:expr, $base:expr, ( &mut executor $( $rest:tt )* )
+        $reg:expr, $base:expr, ( &executor $( $rest:tt )* )
     ) => {
         __graphql__args!(
             @apply_args,

src/macros/enums.rs

@@ -81,7 +81,7 @@ macro_rules! graphql_enum {
                     .into_meta()
             }
 
-            fn resolve(&self, _: Option<Vec<$crate::Selection>>, _: &mut $crate::Executor<CtxT>) -> $crate::Value {
+            fn resolve(&self, _: Option<Vec<$crate::Selection>>, _: &$crate::Executor<CtxT>) -> $crate::Value {
                 match self {
                     $(
                         &graphql_enum!(@as_pattern, $eval) =>

src/macros/interface.rs

@@ -249,7 +249,7 @@ macro_rules! graphql_interface {
 
             #[allow(unused_variables)]
             #[allow(unused_mut)]
-            fn resolve_field(&$mainself, field: &str, args: &$crate::Arguments, mut executor: &mut $crate::Executor<$ctxt>) -> $crate::ExecutionResult {
+            fn resolve_field(&$mainself, field: &str, args: &$crate::Arguments, mut executor: &$crate::Executor<$ctxt>) -> $crate::ExecutionResult {
                 __graphql__build_field_matches!(
                     ($outname, $mainself, field, args, executor),
                     (),
@@ -267,7 +267,7 @@ macro_rules! graphql_interface {
                 &$mainself,
                 type_name: &str,
                 _: Option<Vec<$crate::Selection>>,
-                executor: &mut $crate::Executor<$ctxt>,
+                executor: &$crate::Executor<$ctxt>,
             )
                 -> $crate::ExecutionResult
             {

src/macros/object.rs

@@ -194,15 +194,15 @@ string as documentation on the field.
 ### Field arguments
 
 ```text
-&mut executor
+&executor
 arg_name: ArgType
 arg_name = default_value: ArgType
 arg_name: ArgType as "Argument description"
 arg_name = default_value: ArgType as "Argument description"
 ```
 
 Field arguments can take many forms. If the field needs access to the executor
-or context, it can take an [Executor][1] instance by specifying `&mut executor`
+or context, it can take an [Executor][1] instance by specifying `&executor`
 as the first argument.
 
 The other cases are similar to regular Rust arguments, with two additions:
@@ -382,7 +382,7 @@ macro_rules! graphql_object {
                 &$mainself,
                 field: &str,
                 args: &$crate::Arguments,
-                mut executor: &mut $crate::Executor<$ctxt>
+                executor: &$crate::Executor<$ctxt>
             )
                 -> $crate::ExecutionResult
             {

src/macros/scalar.rs

@@ -76,7 +76,7 @@ macro_rules! graphql_scalar {
             fn resolve(
                 &$resolve_selfvar,
                 _: Option<Vec<$crate::Selection>>,
-                _: &mut $crate::Executor<CtxT>) -> $crate::Value {
+                _: &$crate::Executor<CtxT>) -> $crate::Value {
                 $resolve_body
             }
         }

src/macros/tests/args.rs

@@ -20,8 +20,8 @@ Syntax to validate:
 
 graphql_object!(Root: () |&self| {
     field simple() -> i64 { 0 }
-    field exec_arg(&mut executor) -> i64 { 0 }
-    field exec_arg_and_more(&mut executor, arg: i64) -> i64 { 0 }
+    field exec_arg(&executor) -> i64 { 0 }
+    field exec_arg_and_more(&executor, arg: i64) -> i64 { 0 }
 
     field single_arg(arg: i64) -> i64 { 0 }
     field multi_args(

src/macros/union.rs

@@ -136,7 +136,7 @@ macro_rules! graphql_union {
                 &$mainself,
                 type_name: &str,
                 _: Option<Vec<$crate::Selection>>,
-                executor: &mut $crate::Executor<$ctxt>,
+                executor: &$crate::Executor<$ctxt>,
             )
                 -> $crate::ExecutionResult
             {