Support in macro

Author: tyranron

juniper/Cargo.toml

@@ -81,6 +81,7 @@ void = { version = "1.0.2", optional = true }
 [dev-dependencies]
 bencher = "0.1.2"
 chrono = { version = "0.4.30", features = ["alloc"], default-features = false }
+compact_str = { version = "0.9", features = ["serde"] }
 jiff = { version = "0.2", features = ["tzdb-bundle-always"], default-features = false }
 pretty_assertions = "1.0.0"
 serde_json = "1.0.18"

juniper/src/ast.rs

@@ -572,7 +572,7 @@ where
 
 impl<S: ScalarValue> IntoInputValue<S> for &ArcStr {
     fn into_input_value(self) -> InputValue<S> {
-        InputValue::scalar(S::from_custom_string(self))
+        InputValue::scalar(S::from_displayable(self))
     }
 }
 
@@ -584,7 +584,7 @@ impl<S: ScalarValue> IntoInputValue<S> for ArcStr {
 
 impl<S: ScalarValue> IntoInputValue<S> for &CompactString {
     fn into_input_value(self) -> InputValue<S> {
-        InputValue::scalar(S::from_custom_string(self))
+        InputValue::scalar(S::from_displayable(self))
     }
 }
 

juniper/src/types/scalars.rs

@@ -181,7 +181,7 @@ mod impl_arcstr_scalar {
     use super::ArcStr;
 
     pub(super) fn to_output<S: ScalarValue>(v: &ArcStr) -> Value<S> {
-        Value::scalar(S::from_custom_string(v))
+        Value::scalar(S::from_displayable(v))
     }
 
     pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<ArcStr, String> {
@@ -201,7 +201,7 @@ mod impl_compactstring_scalar {
     use super::CompactString;
 
     pub(super) fn to_output<S: ScalarValue>(v: &CompactString) -> Value<S> {
-        Value::scalar(S::from_custom_string(v))
+        Value::scalar(S::from_displayable(v))
     }
 
     pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<CompactString, String> {

juniper/src/value/mod.rs

@@ -5,7 +5,6 @@ use std::{any::TypeId, borrow::Cow, fmt, mem};
 
 use arcstr::ArcStr;
 use compact_str::CompactString;
-use derive_more::with_trait::From;
 
 use crate::{
     ast::{InputValue, ToInputValue},
@@ -27,10 +26,9 @@ pub use self::{
 /// information since they are generated by resolving fields and values rather
 /// than parsing a source query.
 #[expect(missing_docs, reason = "self-explanatory")]
-#[derive(Clone, Debug, From, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum Value<S = DefaultScalarValue> {
     Null,
-    #[from(ignore)]
     Scalar(S),
     List(Vec<Value<S>>),
     Object(Object<S>),
@@ -297,7 +295,7 @@ where
 
 impl<S: ScalarValue> IntoValue<S> for &ArcStr {
     fn into_value(self) -> Value<S> {
-        Value::scalar(S::from_custom_string(self))
+        Value::scalar(S::from_displayable(self))
     }
 }
 
@@ -309,7 +307,7 @@ impl<S: ScalarValue> IntoValue<S> for ArcStr {
 
 impl<S: ScalarValue> IntoValue<S> for &CompactString {
     fn into_value(self) -> Value<S> {
-        Value::scalar(S::from_custom_string(self))
+        Value::scalar(S::from_displayable(self))
     }
 }
 

juniper/src/value/scalar.rs

@@ -8,6 +8,8 @@ use derive_more::with_trait::From;
 use serde::{Serialize, de::DeserializeOwned};
 
 use crate::parser::{ParseError, ScalarToken};
+#[cfg(doc)]
+use crate::{InputValue, Value};
 
 pub use juniper_codegen::ScalarValue;
 
@@ -20,44 +22,68 @@ pub trait ParseScalarValue<S = DefaultScalarValue> {
     fn from_str(value: ScalarToken<'_>) -> ParseScalarResult<S>;
 }
 
-/// A trait marking a type that could be used as internal representation of
-/// scalar values in juniper
+/// Type that could be used as internal representation of scalar values (e.g. inside [`Value`] and
+/// [`InputValue`]).
 ///
-/// The main objective of this abstraction is to allow other libraries to
-/// replace the default representation with something that better fits their
-/// needs.
-/// There is a custom derive (`#[derive(`[`ScalarValue`]`)]`) available that
-/// implements most of the required traits automatically for a enum representing
-/// a scalar value. However, [`Serialize`] and [`Deserialize`] implementations
+/// This abstraction allows other libraries and user code to replace the default representation with
+/// something that better fits their needs than [`DefaultScalarValue`].
+///
+/// # Deriving
+///
+/// There is a custom derive (`#[derive(`[`ScalarValue`](macro@crate::ScalarValue)`)]`) available,
+/// that implements most of the required traits automatically for an enum representing a
+/// [`ScalarValue`]. However, [`Serialize`] and [`Deserialize`] implementations
 /// are expected to be provided.
 ///
-/// # Implementing a new scalar value representation
-/// The preferred way to define a new scalar value representation is
-/// defining a enum containing a variant for each type that needs to be
-/// represented at the lowest level.
-/// The following example introduces an new variant that is able to store 64 bit
-/// integers.
+/// # Example
+///
+/// The preferred way to define a new [`ScalarValue`] representation is defining an enum containing
+/// a variant for each type that needs to be represented at the lowest level.
+///
+/// The following example introduces a new variant that is able to store 64-bit integers, and uses
+/// a [`CompactString`] for a string representation.
 ///
 /// ```rust
-/// # use std::fmt;
+/// # use std::{any::Any, fmt};
 /// #
-/// # use serde::{de, Deserialize, Deserializer, Serialize};
+/// # use compact_str::CompactString;
 /// # use juniper::ScalarValue;
+/// # use serde::{de, Deserialize, Deserializer, Serialize};
 /// #
 /// #[derive(Clone, Debug, PartialEq, ScalarValue, Serialize)]
 /// #[serde(untagged)]
+/// #[value(from_displayable_with = from_compact_str)]
 /// enum MyScalarValue {
 ///     #[value(as_float, as_int)]
 ///     Int(i32),
 ///     Long(i64),
 ///     #[value(as_float)]
 ///     Float(f64),
 ///     #[value(as_str, as_string, into_string)]
-///     String(String),
+///     String(CompactString),
 ///     #[value(as_bool)]
 ///     Boolean(bool),
 /// }
 ///
+/// // Custom implementation of `ScalarValue::from_displayable()` method
+/// // for efficient conversions from `CompactString` into `MyScalarValue`.
+/// fn from_compact_str<Str: fmt::Display + Any + ?Sized>(s: &Str) -> MyScalarValue {
+///     use juniper::AnyExt as _; // allows downcasting directly on types without `dyn`
+///
+///     if let Some(s) = s.downcast_ref::<CompactString>() {
+///         MyScalarValue::String(s.clone())
+///     } else {
+///         s.to_string().into()
+///     }
+/// }
+/// 
+/// // Macro cannot infer and generate this impl if a custom string type is used. 
+/// impl From<String> for MyScalarValue {
+///     fn from(value: String) -> Self {
+///         Self::String(value.into())
+///     }
+/// }
+///
 /// impl<'de> Deserialize<'de> for MyScalarValue {
 ///     fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error> {
 ///         struct Visitor;
@@ -115,7 +141,7 @@ pub trait ParseScalarValue<S = DefaultScalarValue> {
 ///             }
 ///
 ///             fn visit_string<E: de::Error>(self, s: String) -> Result<Self::Value, E> {
-///                 Ok(MyScalarValue::String(s))
+///                 Ok(MyScalarValue::String(s.into()))
 ///             }
 ///         }
 ///
@@ -124,6 +150,7 @@ pub trait ParseScalarValue<S = DefaultScalarValue> {
 /// }
 /// ```
 ///
+/// [`CompactString`]: compact_str::CompactString
 /// [`Deserialize`]: trait@serde::Deserialize
 /// [`Serialize`]: trait@serde::Serialize
 pub trait ScalarValue:
@@ -228,14 +255,18 @@ pub trait ScalarValue:
         }
     }
 
-    /// Creates this [`ScalarValue`] from the provided custom string type.
+    /// Creates this [`ScalarValue`] from the provided [`fmt::Display`] type.
     ///
     /// This method should be implemented if [`ScalarValue`] implementation uses some custom string
     /// type inside to enable efficient conversion from values of this type.
     ///
     /// Default implementation allocates by converting [`ToString`] and [`From`]`<`[`String`]`>`.
+    ///
+    /// # Example
+    ///
+    /// See the [example in trait documentation](ScalarValue#example) for how it can be used.
     #[must_use]
-    fn from_custom_string<Str: fmt::Display + Any + ?Sized>(s: &Str) -> Self {
+    fn from_displayable<Str: fmt::Display + Any + ?Sized>(s: &Str) -> Self {
         s.to_string().into()
     }
 }

juniper_codegen/src/lib.rs

@@ -415,24 +415,23 @@ pub fn derive_enum(input: TokenStream) -> TokenStream {
 /// struct UserId(String);
 /// ```
 ///
-/// All of the methods inherited from `Newtype`'s field may also be overridden
+/// All the methods inherited from `Newtype`'s field may also be overridden
 /// with the attributes described below.
 ///
 /// # Custom resolving
 ///
 /// Customization of a [GraphQL scalar][0] type resolving is possible via
 /// `#[graphql(to_output_with = <fn path>)]` attribute:
 /// ```rust
-/// # use juniper::{GraphQLScalar, ScalarValue, Value};
+/// # use juniper::{GraphQLScalar, IntoValue as _, ScalarValue, Value};
 /// #
 /// #[derive(GraphQLScalar)]
 /// #[graphql(to_output_with = to_output, transparent)]
 /// struct Incremented(i32);
 ///
 /// /// Increments [`Incremented`] before converting into a [`Value`].
 /// fn to_output<S: ScalarValue>(v: &Incremented) -> Value<S> {
-///     let inc = v.0 + 1;
-///     Value::from(inc)
+///     (v.0 + 1).into_value()
 /// }
 /// ```
 ///
@@ -772,22 +771,25 @@ pub fn graphql_scalar(attr: TokenStream, body: TokenStream) -> TokenStream {
     })
 }
 
-/// `#[derive(ScalarValue)]` macro for deriving a [`ScalarValue`]
-/// implementation.
+/// `#[derive(ScalarValue)]` macro for deriving a [`ScalarValue`] implementation.
 ///
 /// To derive a [`ScalarValue`] on enum you should mark the corresponding enum
 /// variants with `as_int`, `as_float`, `as_string`, `into_string`, `as_str` and
-/// `as_bool` attribute argumentes (names correspond to [`ScalarValue`] required
+/// `as_bool` attribute arguments (names correspond to [`ScalarValue`] required
 /// methods).
 ///
+/// Additional `from_displayable_with` argument could be used to specify a custom
+/// implementation to override the default `ScalarValue::from_displayable()` method.
+///
 /// ```rust
-/// # use std::fmt;
+/// # use std::{any::Any, fmt};
 /// #
 /// # use serde::{de, Deserialize, Deserializer, Serialize};
 /// # use juniper::ScalarValue;
 /// #
 /// #[derive(Clone, Debug, PartialEq, ScalarValue, Serialize)]
 /// #[serde(untagged)]
+/// #[value(from_displayable_with = from_custom_str)]
 /// enum MyScalarValue {
 ///     #[value(as_float, as_int)]
 ///     Int(i32),
@@ -804,6 +806,23 @@ pub fn graphql_scalar(attr: TokenStream, body: TokenStream) -> TokenStream {
 ///     #[value(as_bool)]
 ///     Boolean(bool),
 /// }
+/// 
+/// // Custom implementation of `ScalarValue::from_displayable()` method for 
+/// // possible efficient conversions into `MyScalarValue` from custom string types.
+/// fn from_custom_str<Str: fmt::Display + Any + ?Sized>(s: &Str) -> MyScalarValue {
+///     use juniper::AnyExt as _; // allows downcasting directly on types without `dyn`
+/// 
+///     // Imagine this is some custom optimized string type.
+///     struct CustomString(String);
+///
+///     // We specialize the conversion for this type without going through expensive
+///     // `ToString` -> `From<String>` conversion with allocation.
+///     if let Some(s) = s.downcast_ref::<CustomString>() {
+///         MyScalarValue::String(s.0.clone())
+///     } else {
+///         s.to_string().into()
+///     }
+/// }
 ///
 /// impl<'de> Deserialize<'de> for MyScalarValue {
 ///     fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error> {
@@ -1361,7 +1380,7 @@ pub fn graphql_interface(attr: TokenStream, body: TokenStream) -> TokenStream {
 ///
 /// For more info and possibilities see [`#[graphql_interface]`][0] macro.
 ///
-/// [0]: crate::graphql_interface
+/// [0]: macro@crate::graphql_interface
 /// [1]: https://spec.graphql.org/October2021#sec-Interfaces
 #[proc_macro_derive(GraphQLInterface, attributes(graphql))]
 pub fn derive_interface(body: TokenStream) -> TokenStream {