Rebase onto master

Author: nWacky

benches/bench.rs

@@ -0,0 +1,127 @@
+#[macro_use] extern crate bencher;
+extern crate juniper;
+
+use bencher::Bencher;
+
+use juniper::{execute, RootNode, EmptyMutation, Variables};
+use juniper::tests::model::Database;
+
+fn query_type_name(b: &mut Bencher) {
+    let database = Database::new();
+    let schema = RootNode::new(&database, EmptyMutation::<Database>::new());
+
+    let doc = r#"
+        query IntrospectionQueryTypeQuery {
+          __schema {
+            queryType {
+              name
+            }
+          }
+        }"#;
+
+    b.iter(|| execute(doc, None, &schema, &Variables::new(), &database));
+}
+
+fn introspection_query(b: &mut Bencher) {
+    let database = Database::new();
+    let schema = RootNode::new(&database, EmptyMutation::<Database>::new());
+
+    let doc = r#"
+  query IntrospectionQuery {
+    __schema {
+      queryType { name }
+      mutationType { name }
+      subscriptionType { name }
+      types {
+        ...FullType
+      }
+      directives {
+        name
+        description
+        locations
+        args {
+          ...InputValue
+        }
+      }
+    }
+  }
+
+  fragment FullType on __Type {
+    kind
+    name
+    description
+    fields(includeDeprecated: true) {
+      name
+      description
+      args {
+        ...InputValue
+      }
+      type {
+        ...TypeRef
+      }
+      isDeprecated
+      deprecationReason
+    }
+    inputFields {
+      ...InputValue
+    }
+    interfaces {
+      ...TypeRef
+    }
+    enumValues(includeDeprecated: true) {
+      name
+      description
+      isDeprecated
+      deprecationReason
+    }
+    possibleTypes {
+      ...TypeRef
+    }
+  }
+
+  fragment InputValue on __InputValue {
+    name
+    description
+    type { ...TypeRef }
+    defaultValue
+  }
+
+  fragment TypeRef on __Type {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+"#;
+
+    b.iter(|| execute(doc, None, &schema, &Variables::new(), &database));
+}
+
+benchmark_group!(queries, query_type_name, introspection_query);
+benchmark_main!(queries);

juniper/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 - No changes yet
 
+# [[0.14.1] 2019-10-24](https://github.com/graphql-rust/juniper/releases/tag/juniper-0.14.1)
+
+- Fix panic when an invalid scalar is used by a client [#434](https://github.com/graphql-rust/juniper/pull/434)
+- `EmptyMutation` now implements `Send` [#443](https://github.com/graphql-rust/juniper/pull/443)
+
 # [[0.14.0] 2019-09-29](https://github.com/graphql-rust/juniper/releases/tag/juniper-0.14.0)
 
 - Require `url` 2.x if `url` feature is enabled.

juniper/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "juniper"
-version = "0.14.0"
+version = "0.14.1"
 authors = [
     "Magnus Hallin <[email protected]>",
     "Christoph Herzog <[email protected]>",
@@ -33,7 +33,7 @@ default = [
 ]
 
 [dependencies]
-juniper_codegen = { version = "0.14.0", path = "../juniper_codegen"  }
+juniper_codegen = { version = "0.14.1", path = "../juniper_codegen"  }
 
 async-trait = "0.1.16"
 chrono = { version = "0.4.0", optional = true }

juniper/src/executor/mod.rs

@@ -210,20 +210,6 @@ impl<S> FieldError<S> {
 /// The result of resolving the value of a field of type `T`
 pub type FieldResult<T, S = DefaultScalarValue> = Result<T, FieldError<S>>;
 
-/*
-pub enum ResolvedValue<'a, S = DefaultScalarValue> {
-    Value(Value<S>),
-    Future(crate::BoxFuture<'a, Value<S>>),
-}
-
-impl<'a, S> From<Value<S>> for ResolvedValue<'a, S> {
-    #[inline]
-    fn from(value: Value<S>) -> Self {
-        ResolvedValue::Value(value)
-    }
-}
-*/
-
 /// The result of resolving an unspecified field
 pub type ExecutionResult<S = DefaultScalarValue> = Result<Value<S>, FieldError<S>>;
 

juniper/src/lib.rs

@@ -88,7 +88,7 @@ Juniper has not reached 1.0 yet, thus some API instability should be expected.
 [chrono]: https://crates.io/crates/chrono
 
 */
-#![doc(html_root_url = "https://docs.rs/juniper/0.14.0")]
+#![doc(html_root_url = "https://docs.rs/juniper/0.14.1")]
 #![warn(missing_docs)]
 
 #[doc(hidden)]
@@ -151,6 +151,7 @@ mod executor_tests;
 pub use crate::util::to_camel_case;
 
 use crate::{
+    executor::{execute_validated_query, execute_validated_query_async},
     introspection::{INTROSPECTION_QUERY, INTROSPECTION_QUERY_WITHOUT_DESCRIPTIONS},
     parser::{parse_document_source, ParseError, Spanning},
     validation::{validate_input_values, visit_all_rules, ValidatorContext},
@@ -227,7 +228,7 @@ where
         }
     }
 
-    executor::execute_validated_query(document, operation_name, root_node, variables, context)
+    execute_validated_query(document, operation_name, root_node, variables, context)
 }
 
 /// Execute a query in a provided schema
@@ -267,7 +268,7 @@ where
         }
     }
 
-    executor::execute_validated_query_async(document, operation_name, root_node, variables, context)
+    execute_validated_query_async(document, operation_name, root_node, variables, context)
         .await
 }
 

juniper/src/parser/parser.rs

@@ -13,6 +13,9 @@ pub enum ParseError<'a> {
 
     /// An error during tokenization occurred
     LexerError(LexerError),
+
+    /// A scalar of unexpected type occurred in the source
+    ExpectedScalarError(&'static str),
 }
 
 #[doc(hidden)]
@@ -196,6 +199,7 @@ impl<'a> fmt::Display for ParseError<'a> {
             ParseError::UnexpectedToken(ref token) => write!(f, "Unexpected \"{}\"", token),
             ParseError::UnexpectedEndOfFile => write!(f, "Unexpected end of input"),
             ParseError::LexerError(ref err) => err.fmt(f),
+            ParseError::ExpectedScalarError(err) => err.fmt(f),
         }
     }
 }

juniper/src/parser/tests/document.rs

@@ -4,6 +4,7 @@ use crate::{
     },
     parser::{document::parse_document_source, ParseError, SourcePosition, Spanning, Token},
     schema::model::SchemaType,
+    types::scalars::EmptyMutation,
     validation::test_harness::{MutationRoot, QueryRoot},
     value::{DefaultScalarValue, ScalarRefValue, ScalarValue},
 };
@@ -145,3 +146,23 @@ fn errors() {
         )
     );
 }
+
+#[test]
+fn issue_427_panic_is_not_expected() {
+    struct QueryWithoutFloat;
+
+    #[crate::object_internal]
+    impl QueryWithoutFloat {
+        fn echo(value: String) -> String {
+            value
+        }
+    }
+
+    let schema = SchemaType::new::<QueryWithoutFloat, EmptyMutation<()>>(&(), &());
+    let parse_result = parse_document_source(r##"{ echo(value: 123.0) }"##, &schema);
+
+    assert_eq!(
+        parse_result.unwrap_err().item,
+        ParseError::ExpectedScalarError("There needs to be a Float type")
+    );
+}

juniper/src/parser/value.rs

@@ -210,33 +210,36 @@ fn parse_scalar_literal_by_infered_type<'a, 'b, S>(
 where
     S: ScalarValue,
 {
-    match token {
+    let result = match token {
         ScalarToken::String(_) => {
             if let Some(&MetaType::Scalar(ref s)) = schema.concrete_type_by_name("String") {
-                (s.parse_fn)(token)
-                    .map(|s| Spanning::start_end(start, end, InputValue::Scalar(s)))
-                    .map_err(|e| Spanning::start_end(start, end, e))
+                (s.parse_fn)(token).map(InputValue::Scalar)
             } else {
-                panic!("There needs to be a String type")
+                Err(ParseError::ExpectedScalarError(
+                    "There needs to be a String type",
+                ))
             }
         }
         ScalarToken::Int(_) => {
             if let Some(&MetaType::Scalar(ref s)) = schema.concrete_type_by_name("Int") {
-                (s.parse_fn)(token)
-                    .map(|s| Spanning::start_end(start, end, InputValue::Scalar(s)))
-                    .map_err(|e| Spanning::start_end(start, end, e))
+                (s.parse_fn)(token).map(InputValue::Scalar)
             } else {
-                panic!("There needs to be a Int type")
+                Err(ParseError::ExpectedScalarError(
+                    "There needs to be an Int type",
+                ))
             }
         }
         ScalarToken::Float(_) => {
             if let Some(&MetaType::Scalar(ref s)) = schema.concrete_type_by_name("Float") {
-                (s.parse_fn)(token)
-                    .map(|s| Spanning::start_end(start, end, InputValue::Scalar(s)))
-                    .map_err(|e| Spanning::start_end(start, end, e))
+                (s.parse_fn)(token).map(InputValue::Scalar)
             } else {
-                panic!("There needs to be a Float type")
+                Err(ParseError::ExpectedScalarError(
+                    "There needs to be a Float type",
+                ))
             }
         }
-    }
+    };
+    result
+        .map(|s| Spanning::start_end(start, end, s))
+        .map_err(|e| Spanning::start_end(start, end, e))
 }

juniper/src/types/base.rs

@@ -343,7 +343,7 @@ where
     }
 }
 
-pub fn resolve_selection_set_into<T, CtxT, S>(
+pub(crate) fn resolve_selection_set_into<T, CtxT, S>(
     instance: &T,
     info: &T::TypeInfo,
     selection_set: &[Selection<S>],

juniper/src/types/scalars.rs

@@ -308,6 +308,9 @@ impl<T> EmptyMutation<T> {
     }
 }
 
+// This is safe due to never using `T`.
+unsafe impl<T> Send for EmptyMutation<T> {}
+
 impl<S, T> GraphQLType<S> for EmptyMutation<T>
 where
     S: ScalarValue,
@@ -343,7 +346,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::ID;
+    use super::{EmptyMutation, ID};
     use crate::{
         parser::ScalarToken,
         value::{DefaultScalarValue, ParseScalarValue},
@@ -390,4 +393,10 @@ mod tests {
             "unicode \u{1234}\u{5678}\u{90ab}\u{cdef}",
         );
     }
+
+    #[test]
+    fn empty_mutation_is_send() {
+        fn check_if_send<T: Send>() {}
+        check_if_send::<EmptyMutation<()>>();
+    }
 }

juniper/src/value/scalar.rs

@@ -260,8 +260,6 @@ pub enum DefaultScalarValue {
     Boolean(bool),
 }
 
-trait S: Send + Sync {}
-
 impl ScalarValue for DefaultScalarValue {
     type Visitor = DefaultScalarValueVisitor;
 

juniper_codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "juniper_codegen"
-version = "0.14.0"
+version = "0.14.1"
 authors = [
     "Magnus Hallin <[email protected]>",
     "Christoph Herzog <[email protected]>",
@@ -24,7 +24,7 @@ quote = "1.0.2"
 proc-macro-error = "0.3.4"
 
 [dev-dependencies]
-juniper = { version = "0.14.0", path = "../juniper" }
+juniper = { version = "0.14.1", path = "../juniper" }
 
 [badges]
 travis-ci = { repository = "graphql-rust/juniper" }

juniper_hyper/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 - Compatibility with the latest `juniper`.
 
+# [[0.5.1] 2019-10-24](https://github.com/graphql-rust/juniper/releases/tag/juniper_hyper-0.5.1)
+
+- Compatibility with the latest `juniper`.
+
 # [[0.5.0] 2019-09-29](https://github.com/graphql-rust/juniper/releases/tag/juniper_hyper-0.5.0)
 
 - Compatibility with the latest `juniper`.