Something that works

Author: tyranron

juniper/src/integrations/bigdecimal.rs

@@ -54,7 +54,7 @@ mod bigdecimal_scalar {
                 .map_err(|e| format!("Failed to parse `BigDecimal` from `Float`: {e}").into())
         } else {
             v.try_to::<&str>()
-                .map_err(|e| e.to_string().into())
+                .map_err(|e| e.message().into())
                 .and_then(|s| {
                     BigDecimal::from_str(s).map_err(|e| {
                         format!("Failed to parse `BigDecimal` from `String`: {e}").into()

juniper/src/integrations/rust_decimal.rs

@@ -48,7 +48,7 @@ mod rust_decimal_scalar {
                 .map_err(|e| format!("Failed to parse `Decimal` from `Float`: {e}").into())
         } else {
             v.try_to::<&str>()
-                .map_err(|e| e.to_string().into())
+                .map_err(|e| e.message().into())
                 .and_then(|s| {
                     Decimal::from_str(s)
                         .map_err(|e| format!("Failed to parse `Decimal` from `String`: {e}").into())

juniper/src/types/pointers.rs

@@ -87,13 +87,13 @@ where
     }
 }
 
-impl<T, S> FromScalarValue<S> for Box<T>
+impl<'s, T, S> FromScalarValue<'s, S> for Box<T>
 where
     S: ScalarValue,
-    T: FromScalarValue<S>,
+    T: FromScalarValue<'s, S> + 's,
 {
-    fn from_scalar_value(v: &S) -> FieldResult<Self, S> {
-        <T as FromScalarValue<S>>::from_scalar_value(v).map(Self::new)
+    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+        T::from_scalar_value(v).map(Self::new)
     }
 }
 
@@ -285,13 +285,13 @@ where
     }
 }
 
-impl<T, S> FromScalarValue<S> for Arc<T>
+impl<'s, T, S> FromScalarValue<'s, S> for Arc<T>
 where
     S: ScalarValue,
-    T: FromScalarValue<S>,
+    T: FromScalarValue<'s, S> + 's,
 {
-    fn from_scalar_value(v: &S) -> FieldResult<Self, S> {
-        <T as FromScalarValue<S>>::from_scalar_value(v).map(Self::new)
+    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+        T::from_scalar_value(v).map(Self::new)
     }
 }
 

juniper/src/types/scalars.rs

@@ -4,7 +4,7 @@ use derive_more::with_trait::{Deref, Display, From, Into};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    IntoFieldError,FieldResult, GraphQLScalar, Scalar,
+    FieldResult, GraphQLScalar, IntoFieldError, Scalar,
     ast::{InputValue, Selection, ToInputValue},
     executor::{ExecutionResult, Executor, Registry},
     graphql_scalar,
@@ -16,7 +16,10 @@ use crate::{
         base::{GraphQLType, GraphQLValue},
         subscriptions::GraphQLSubscriptionValue,
     },
-    value::{FromScalarValue, ParseScalarResult, ScalarValue, Value, WrongInputScalarTypeError},
+    value::{
+        FromScalarValue, ParseScalarResult, ScalarValue, TryScalarValueTo, Value,
+        WrongInputScalarTypeError,
+    },
 };
 
 /// An ID as defined by the GraphQL specification
@@ -56,7 +59,7 @@ impl ID {
 }
 
 #[graphql_scalar]
-#[graphql(with = impl_string_scalar, from_input_with = identity::<String>)]
+#[graphql(with = impl_string_scalar, from_input_with = __builtin)]
 type String = std::string::String;
 
 mod impl_string_scalar {
@@ -170,21 +173,22 @@ where
     })
 }
 
+
 #[graphql_scalar]
 #[graphql(name = "String", with = impl_arcstr_scalar, parse_token(String))]
 type ArcStr = arcstr::ArcStr;
 
 mod impl_arcstr_scalar {
     use super::ArcStr;
-    use crate::{IntoValue as _, Scalar, ScalarValue, TryScalarValueTo, Value};
+    use crate::{IntoValue as _, Scalar, ScalarValue, Value, FieldResult};
 
     pub(super) fn to_output<S: ScalarValue>(v: &ArcStr) -> Value<S> {
         v.into_value()
     }
-
+    
     pub(super) fn from_input<S: ScalarValue>(
         v: &Scalar<S>,
-    ) -> Result<ArcStr, <S as TryScalarValueTo<'_, &str>>::Error> {
+    ) -> FieldResult<ArcStr, S> {
         if let Some(s) = v.downcast_type::<ArcStr>() {
             Ok(s.clone())
         } else {
@@ -199,15 +203,15 @@ type CompactString = compact_str::CompactString;
 
 mod impl_compactstring_scalar {
     use super::CompactString;
-    use crate::{IntoValue as _, Scalar, ScalarValue, TryScalarValueTo, Value};
+    use crate::{IntoValue as _, Scalar, ScalarValue, FieldResult, Value};
 
     pub(super) fn to_output<S: ScalarValue>(v: &CompactString) -> Value<S> {
         v.into_value()
     }
 
     pub(super) fn from_input<S: ScalarValue>(
         v: &Scalar<S>,
-    ) -> Result<CompactString, <S as TryScalarValueTo<'_, &str>>::Error> {
+    ) -> FieldResult<CompactString, S> {
         if let Some(s) = v.downcast_type::<CompactString>() {
             Ok(s.clone())
         } else {
@@ -286,8 +290,18 @@ where
     }
 }
 
+impl<'s, S> FromScalarValue<'s, S> for &'s str
+where
+    S: TryScalarValueTo<'s, Self, Error: IntoFieldError<S>> + 's,
+{
+    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+        v.try_scalar_value_to()
+            .map_err(IntoFieldError::into_field_error)
+    }
+}
+
 #[graphql_scalar]
-#[graphql(with = impl_boolean_scalar, from_input_with = identity::<Boolean>)]
+#[graphql(with = impl_boolean_scalar, from_input_with = __builtin)]
 type Boolean = bool;
 
 mod impl_boolean_scalar {
@@ -304,7 +318,7 @@ mod impl_boolean_scalar {
 }
 
 #[graphql_scalar]
-#[graphql(with = impl_int_scalar, from_input_with = identity::<Int>)]
+#[graphql(with = impl_int_scalar, from_input_with = __builtin)]
 type Int = i32;
 
 mod impl_int_scalar {
@@ -326,7 +340,7 @@ mod impl_int_scalar {
 }
 
 #[graphql_scalar]
-#[graphql(with = impl_float_scalar, from_input_with = identity::<Float>)]
+#[graphql(with = impl_float_scalar, from_input_with = __builtin)]
 type Float = f64;
 
 mod impl_float_scalar {

juniper/src/value/scalar.rs

@@ -248,16 +248,14 @@ pub trait ScalarValue:
     ///
     /// ```rust
     /// # use arcstr::ArcStr;
-    /// # use juniper::{GraphQLScalar, Scalar, ScalarValue, TryScalarValueTo, Value};
+    /// # use juniper::{FieldResult, GraphQLScalar, Scalar, ScalarValue, TryScalarValueTo, Value};
     /// #
     /// #[derive(GraphQLScalar)]
     /// #[graphql(from_input_with = Self::from_input, transparent)]
     /// struct Name(ArcStr);
     ///
     /// impl Name {
-    ///     fn from_input<S: ScalarValue>(
-    ///         v: &Scalar<S>,
-    ///     ) -> Result<Self, <S as TryScalarValueTo<'_, &str>>::Error> {
+    ///     fn from_input<S: ScalarValue>(v: &Scalar<S>) -> FieldResult<Self, S> {
     ///         // Check if our `ScalarValue` is represented by an `ArcStr` already, and if so,
     ///         // do the cheap `Clone` instead of allocating a new `ArcStr` in its `From<&str>`
     ///         // implementation.
@@ -302,12 +300,11 @@ pub trait ScalarValue:
     ///
     /// Implementations should not implement this method, but rather implement the
     /// [`TryScalarValueTo<T>`] conversion directly.
-    fn try_to<'a, T>(&'a self) -> Result<T, <Self as TryScalarValueTo<'a, Scalar<T>>>::Error>
+    fn try_to<'a, T>(&'a self) -> FieldResult<T, Self>
     where
-        T: 'a,
-        Self: TryScalarValueTo<'a, Scalar<T>, Error: IntoFieldError<Self>>,
+        T: FromScalarValue<'a, Self> + 'a,
     {
-        self.try_scalar_value_to().map(|s: Scalar<T>| s.0)
+        T::from_scalar_value(self)
     }
 
     /// Tries to represent this [`ScalarValue`] as a [`bool`] value.
@@ -324,7 +321,7 @@ pub trait ScalarValue:
     /// [`TryScalarValueTo<bool>`] conversions for all the supported boolean types.
     #[must_use]
     fn try_to_bool(&self) -> Option<bool> {
-        self.try_to().ok()
+        self.try_scalar_value_to().ok()
     }
 
     /// Tries to represent this [`ScalarValue`] as an [`i32`] value.
@@ -342,7 +339,7 @@ pub trait ScalarValue:
     /// less to an integer, if requested.
     #[must_use]
     fn try_to_int(&self) -> Option<i32> {
-        self.try_to().ok()
+        self.try_scalar_value_to().ok()
     }
 
     /// Tries to represent this [`ScalarValue`] as a [`f64`] value.
@@ -360,7 +357,7 @@ pub trait ScalarValue:
     /// all floating point values with 64 bit or less to a float, if requested.
     #[must_use]
     fn try_to_float(&self) -> Option<f64> {
-        self.try_to().ok()
+        self.try_scalar_value_to().ok()
     }
 
     /// Tries to represent this [`ScalarValue`] as a [`String`] value.
@@ -380,7 +377,7 @@ pub trait ScalarValue:
     /// [`TryScalarValueTo<String>`] conversions for all the supported string types, if requested.
     #[must_use]
     fn try_to_string(&self) -> Option<String> {
-        self.try_to().ok()
+        self.try_scalar_value_to().ok()
     }
 
     /// Tries to convert this [`ScalarValue`] into a [`String`] value.
@@ -417,7 +414,7 @@ pub trait ScalarValue:
     /// requested.
     #[must_use]
     fn try_as_str(&self) -> Option<&str> {
-        self.try_to().ok()
+        self.try_scalar_value_to().ok()
     }
 
     /// Converts this [`ScalarValue`] into another one via [`i32`], [`f64`], [`bool`] or [`String`]
@@ -496,25 +493,33 @@ impl<'me, S: ScalarValue> TryScalarValueTo<'me, &'me Scalar<S>> for S {
     }
 }
 
-impl<'me, S: ScalarValue> TryScalarValueTo<'me, Scalar<&'me str>> for S {
+impl<'me, T, S> TryScalarValueTo<'me, Scalar<T>> for S
+where
+    T: FromScalarValue<'me, S> + 'me,
+    S: ScalarValue,
+{
     type Error = FieldError<Self>;
 
-    fn try_scalar_value_to(&'me self) -> FieldResult<Scalar<&'me str>, Self> {
-        self.try_scalar_value_to().map(Scalar)
+    fn try_scalar_value_to(&'me self) -> FieldResult<Scalar<T>, Self> {
+        T::from_scalar_value(self).map(Scalar)
     }
 }
 
-impl<'me, T: FromScalarValue<S> + 'me, S: ScalarValue> TryScalarValueTo<'me, Scalar<T>> for S {
-    type Error = FieldError<Self>;
+pub trait FromScalarValue<'s, S: 's = DefaultScalarValue>: Sized {
+    /// Performs the conversion.
+    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S>;
+}
 
-    fn try_scalar_value_to(&'me self) -> FieldResult<Scalar<T>, Self> {
-        T::from_scalar_value(self).map(Scalar)
+impl<'s, S> FromScalarValue<'s, S> for &'s S {
+    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+        Ok(v)
     }
 }
 
-pub trait FromScalarValue<S = DefaultScalarValue>: Sized {
-    /// Performs the conversion.
-    fn from_scalar_value(v: &S) -> FieldResult<Self, S>;
+impl<'s, S> FromScalarValue<'s, S> for &'s Scalar<S> {
+    fn from_scalar_value(v: &'s S) -> FieldResult<Self, S> {
+        Ok(Scalar::ref_cast(v))
+    }
 }
 
 /// Error of a [`ScalarValue`] not matching the expected type.

juniper_codegen/src/graphql_scalar/mod.rs

@@ -495,41 +495,59 @@ impl Definition {
     fn impl_from_scalar_value_tokens(&self) -> TokenStream {
         let scalar = &self.scalar;
 
-        let (ty, generics) = self.impl_self_and_generics(false);
-        let (impl_gens, _, where_clause) = generics.split_for_impl();
+        let ref_lt = quote! { '___a };
+        let (ty, mut generics) = self.impl_self_and_generics(false);
+        generics.params.push(parse_quote! { #ref_lt });
+        generics.make_where_clause().predicates.push(parse_quote! {
+            Self: #ref_lt
+        });
 
         let body = match &self.methods {
             Methods::Custom { from_input, .. }
             | Methods::Delegated {
                 from_input: Some(from_input),
                 ..
             } => {
-                quote! {
-                    use ::juniper::macros::helper::ToResultCall as _;
-
-                    let input = ::juniper::TryScalarValueTo::try_scalar_value_to(input)
-                        .map_err(::juniper::executor::IntoFieldError::<#scalar>::into_field_error)?;
-                    let func: fn(_) -> _ = #from_input;
-                    (&&func)
-                        .__to_result_call(input)
-                        .map_err(::juniper::executor::IntoFieldError::<#scalar>::into_field_error)
+                if from_input == &parse_quote! { __builtin } {
+                    quote! {
+                        ::juniper::TryScalarValueTo::try_scalar_value_to(input)
+                            .map_err(::juniper::executor::IntoFieldError::<#scalar>::into_field_error)
+                    }
+                } else {
+                    quote! {
+                        use ::juniper::macros::helper::ToResultCall as _;
+
+                        let input = ::juniper::ScalarValue::try_to(input)?;
+                        let func: fn(_) -> _ = #from_input;
+                        (&&func)
+                            .__to_result_call(input)
+                            .map_err(::juniper::executor::IntoFieldError::<#scalar>::into_field_error)
+                    }
                 }
             }
             Methods::Delegated { field, .. } => {
                 let field_ty = field.ty();
                 let self_constructor = field.closure_constructor();
 
+                generics.make_where_clause().predicates.push(parse_quote! {
+                    #field_ty: ::juniper::FromScalarValue<#ref_lt, #scalar>
+                });
+
                 quote! {
-                    <#field_ty as ::juniper::FromScalarValue<#scalar>>::from_scalar_value(input)
-                        .map(#self_constructor)
+                    <#field_ty as ::juniper::FromScalarValue<#ref_lt, #scalar>>
+                        ::from_scalar_value(input).map(#self_constructor)
                 }
             }
         };
 
+        let (lt_impl_gens, _, where_clause) = generics.split_for_impl();
+
         quote! {
             #[automatically_derived]
-            impl #impl_gens ::juniper::FromScalarValue<#scalar> for #ty #where_clause {
-                fn from_scalar_value(input: &#scalar) -> ::juniper::FieldResult<Self, #scalar> {
+            impl #lt_impl_gens ::juniper::FromScalarValue<#ref_lt, #scalar> for #ty #where_clause {
+                fn from_scalar_value(
+                    input: &#ref_lt #scalar,
+                ) -> ::juniper::FieldResult<Self, #scalar> {
                     #body
                 }
             }