Base IntoValue and IntoInputValue conversions on ToScalarValue

Author: tyranron

juniper/src/ast.rs

@@ -8,7 +8,7 @@ use indexmap::IndexMap;
 use crate::{
     executor::Variables,
     parser::Spanning,
-    value::{DefaultScalarValue, Scalar, ScalarValue},
+    value::{DefaultScalarValue, Scalar, ScalarValue, ToScalarValue},
 };
 
 /// Type literal in a syntax tree.
@@ -243,7 +243,7 @@ impl<S> InputValue<S> {
         Self::Null
     }
 
-    /// Construct a scalar value
+    /// Construct a scalar value.
     pub fn scalar<T: Into<S>>(v: T) -> Self {
         Self::Scalar(v.into())
     }
@@ -498,81 +498,79 @@ where
     }
 }
 
-impl<S> IntoInputValue<S> for &str
+impl<T, S> IntoInputValue<S> for &T
 where
-    String: Into<S>,
+    T: ToScalarValue<S> + ?Sized,
 {
     fn into_input_value(self) -> InputValue<S> {
-        InputValue::scalar(self.to_owned())
+        InputValue::Scalar(self.to_scalar_value())
     }
 }
 
-impl<S> IntoInputValue<S> for Cow<'_, str>
+impl<S> IntoInputValue<S> for String
 where
     String: Into<S>,
 {
     fn into_input_value(self) -> InputValue<S> {
-        InputValue::scalar(self.into_owned())
+        InputValue::Scalar(self.into())
     }
 }
 
-impl<S> IntoInputValue<S> for String
+impl<S> IntoInputValue<S> for Cow<'_, str>
 where
-    String: Into<S>,
+    for<'a> &'a str: IntoInputValue<S>,
+    String: IntoInputValue<S>,
 {
     fn into_input_value(self) -> InputValue<S> {
-        InputValue::scalar(self)
-    }
-}
-
-impl<S: ScalarValue> IntoInputValue<S> for &ArcStr {
-    fn into_input_value(self) -> InputValue<S> {
-        InputValue::scalar(S::from_displayable(self))
-    }
-}
-
-impl<S: ScalarValue> IntoInputValue<S> for ArcStr {
-    fn into_input_value(self) -> InputValue<S> {
-        (&self).into_input_value()
+        match self {
+            Cow::Borrowed(s) => s.into_input_value(),
+            Cow::Owned(s) => s.into_input_value(),
+        }
     }
 }
 
-impl<S: ScalarValue> IntoInputValue<S> for &CompactString {
+impl<S: ScalarValue> IntoInputValue<S> for ArcStr
+where
+    ArcStr: ToScalarValue<S>,
+{
     fn into_input_value(self) -> InputValue<S> {
-        InputValue::scalar(S::from_displayable(self))
+        InputValue::Scalar(self.to_scalar_value())
     }
 }
 
-impl<S: ScalarValue> IntoInputValue<S> for CompactString {
+impl<S: ScalarValue> IntoInputValue<S> for CompactString
+where
+    CompactString: ToScalarValue<S>,
+{
     fn into_input_value(self) -> InputValue<S> {
-        (&self).into_input_value()
+        InputValue::Scalar(self.to_scalar_value())
     }
 }
 
 impl<S> IntoInputValue<S> for i32
 where
-    i32: Into<S>,
+    i32: ToScalarValue<S>,
 {
     fn into_input_value(self) -> InputValue<S> {
-        InputValue::scalar(self)
+        InputValue::Scalar(self.to_scalar_value())
     }
 }
 
 impl<S> IntoInputValue<S> for f64
 where
-    f64: Into<S>,
+    f64: ToScalarValue<S>,
 {
     fn into_input_value(self) -> InputValue<S> {
-        InputValue::scalar(self)
+        InputValue::Scalar(self.to_scalar_value())
     }
 }
 
 impl<S> IntoInputValue<S> for bool
 where
-    bool: Into<S>,
+    bool: ToScalarValue<S>,
 {
     fn into_input_value(self) -> InputValue<S> {
-        InputValue::scalar(self)
+        InputValue::Scalar(self.to_scalar_value())
     }
 }
 

juniper/src/integrations/serde.rs

@@ -352,12 +352,7 @@ impl<'de> Deserialize<'de> for DefaultScalarValue {
 mod tests {
     use serde_json::{from_str, to_string};
 
-    use crate::{
-        FieldError, Value,
-        ast::InputValue,
-        graphql_input_value,
-        value::{DefaultScalarValue, Object},
-    };
+    use crate::{DefaultScalarValue, FieldError, InputValue, graphql_input_value, graphql_value};
 
     use super::{ExecutionError, GraphQLError};
 
@@ -392,13 +387,10 @@ mod tests {
 
     #[test]
     fn error_extensions() {
-        let mut obj: Object<DefaultScalarValue> = Object::with_capacity(1);
-        obj.add_field("foo", Value::scalar("bar"));
         assert_eq!(
-            to_string(&ExecutionError::at_origin(FieldError::new(
-                "foo error",
-                Value::Object(obj),
-            )))
+            to_string(&ExecutionError::at_origin(
+                FieldError::<DefaultScalarValue>::new("foo error", graphql_value!({"foo": "bar"})),
+            ))
             .unwrap(),
             r#"{"message":"foo error","locations":[{"line":1,"column":1}],"path":[],"extensions":{"foo":"bar"}}"#,
         );

juniper/src/types/async_await.rs

@@ -222,7 +222,7 @@ where
                 if f.name.item == "__typename" {
                     object.add_field(
                         response_name,
-                        Value::scalar(instance.concrete_type_name(executor.context(), info)),
+                        Value::Scalar(instance.concrete_type_name(executor.context(), info).into()),
                     );
                     continue;
                 }

juniper/src/types/base.rs

@@ -444,7 +444,7 @@ where
                 if f.name.item == "__typename" {
                     result.add_field(
                         response_name,
-                        Value::scalar(instance.concrete_type_name(executor.context(), info)),
+                        Value::Scalar(instance.concrete_type_name(executor.context(), info).into()),
                     );
                     continue;
                 }

juniper/src/types/scalars.rs

@@ -274,7 +274,7 @@ where
         _: Option<&[Selection<S>]>,
         _: &Executor<Self::Context, S>,
     ) -> ExecutionResult<S> {
-        Ok(Value::scalar(String::from(self)))
+        Ok(Value::Scalar(self.to_scalar_value()))
     }
 }
 
@@ -287,7 +287,7 @@ where
         info: &'a Self::TypeInfo,
         selection_set: Option<&'a [Selection<S>]>,
         executor: &'a Executor<Self::Context, S>,
-    ) -> crate::BoxFuture<'a, crate::ExecutionResult<S>> {
+    ) -> crate::BoxFuture<'a, ExecutionResult<S>> {
         use futures::future;
         Box::pin(future::ready(self.resolve(info, selection_set, executor)))
     }

juniper/src/value/mod.rs

@@ -54,7 +54,7 @@ impl<S> Value<S> {
         Self::Object(o)
     }
 
-    /// Construct a scalar value
+    /// Construct a scalar value.
     pub fn scalar<T: Into<S>>(s: T) -> Self {
         Self::Scalar(s.into())
     }
@@ -230,81 +230,79 @@ where
     }
 }
 
-impl<S> IntoValue<S> for &str
+impl<T, S> IntoValue<S> for &T
 where
-    String: Into<S>,
+    T: ToScalarValue<S> + ?Sized,
 {
     fn into_value(self) -> Value<S> {
-        Value::scalar(self.to_owned())
+        Value::Scalar(self.to_scalar_value())
     }
 }
 
-impl<S> IntoValue<S> for Cow<'_, str>
+impl<S> IntoValue<S> for String
 where
     String: Into<S>,
 {
     fn into_value(self) -> Value<S> {
-        Value::scalar(self.into_owned())
+        Value::Scalar(self.into())
     }
 }
 
-impl<S> IntoValue<S> for String
+impl<S> IntoValue<S> for Cow<'_, str>
 where
-    String: Into<S>,
+    for<'a> &'a str: IntoValue<S>,
+    String: IntoValue<S>,
 {
     fn into_value(self) -> Value<S> {
-        Value::scalar(self)
-    }
-}
-
-impl<S: ScalarValue> IntoValue<S> for &ArcStr {
-    fn into_value(self) -> Value<S> {
-        Value::scalar(S::from_displayable(self))
-    }
-}
-
-impl<S: ScalarValue> IntoValue<S> for ArcStr {
-    fn into_value(self) -> Value<S> {
-        (&self).into_value()
+        match self {
+            Cow::Borrowed(s) => s.into_value(),
+            Cow::Owned(s) => s.into_value(),
+        }
     }
 }
 
-impl<S: ScalarValue> IntoValue<S> for &CompactString {
+impl<S: ScalarValue> IntoValue<S> for ArcStr
+where
+    ArcStr: ToScalarValue<S>,
+{
     fn into_value(self) -> Value<S> {
-        Value::scalar(S::from_displayable(self))
+        Value::Scalar(self.to_scalar_value())
     }
 }
 
-impl<S: ScalarValue> IntoValue<S> for CompactString {
+impl<S: ScalarValue> IntoValue<S> for CompactString
+where
+    CompactString: ToScalarValue<S>,
+{
     fn into_value(self) -> Value<S> {
-        (&self).into_value()
+        Value::Scalar(self.to_scalar_value())
     }
 }
 
 impl<S> IntoValue<S> for i32
 where
-    i32: Into<S>,
+    i32: ToScalarValue<S>,
 {
     fn into_value(self) -> Value<S> {
-        Value::scalar(self)
+        Value::Scalar(self.to_scalar_value())
     }
 }
 
 impl<S> IntoValue<S> for f64
 where
-    f64: Into<S>,
+    f64: ToScalarValue<S>,
 {
     fn into_value(self) -> Value<S> {
-        Value::scalar(self)
+        Value::Scalar(self.to_scalar_value())
     }
 }
 
 impl<S> IntoValue<S> for bool
 where
-    bool: Into<S>,
+    bool: ToScalarValue<S>,
 {
     fn into_value(self) -> Value<S> {
-        Value::scalar(self)
+        Value::Scalar(self.to_scalar_value())
     }
 }