Upd Book

Author: tyranron

book/Cargo.toml

@@ -7,6 +7,8 @@ publish = false
 
 [dependencies]
 dataloader = "0.18" # for Book only
+derive_more = { version = "2.0", features = ["display", "from", "try_into"] }
+juniper = { path = "../juniper", features = ["jiff"] }
 
 [lints.clippy]
 allow_attributes = "warn"

book/src/lib.rs

@@ -1,3 +1,4 @@
 //! Crate keeping dependencies for running Book tests.
 
 use dataloader as _;
+use juniper as _;

book/src/types/scalars.md

@@ -85,15 +85,49 @@ pub struct UserId(String);
 In case we need to customize [resolving][7] of a [custom GraphQL scalar][2] value (change the way it gets executed), the `#[graphql(to_output_with = <fn path>)]` attribute is the way to do so:
 ```rust
 # extern crate juniper;
-# use juniper::{GraphQLScalar, IntoValue as _, ScalarValue, Value};
+# use juniper::GraphQLScalar;
 #
 #[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> {
-    (v.0 + 1).into_value()
+fn to_output(v: &Incremented) -> i32 {
+    //                           ^^^ any concrete type having `ToScalarValue` implementation
+    //                               could be used
+    v.0 + 1
+}
+#
+# fn main() {}
+```
+
+The provided function is polymorphic by its output type:
+```rust
+# extern crate jiff;
+# extern crate juniper;
+# use std::fmt::Display;
+# use juniper::{GraphQLScalar, ScalarValue};
+#
+#[derive(GraphQLScalar)]
+#[graphql(to_output_with = Self::to_output, transparent)]
+struct Incremented(i32);
+
+impl Incremented {
+    fn to_output<S: ScalarValue>(v: &Incremented) -> S {
+        //       ^^^^^^^^^^^^^^ returning generic or concrete `ScalarValue` is also OK
+        (v.0 + 1).into()
+    }
+}
+
+#[derive(GraphQLScalar)]
+#[graphql(to_output_with = Self::to_output, transparent)]
+struct CustomDateTime(jiff::Timestamp);
+
+impl CustomDateTime {
+    fn to_output(&self) -> impl Display {
+        //                 ^^^^^^^^^^^^ in this case macro expansion uses the
+        //                              `ScalarValue::from_displayable_non_static()` conversion
+        self.0.strftime("%Y-%m-%d %H:%M:%S%.fZ")
+    }
 }
 #
 # fn main() {}
@@ -117,7 +151,7 @@ impl UserId {
         input: &str,
         //     ^^^^ any concrete type having `FromScalarValue` implementation could be used
     ) -> Result<Self, Box<str>> {
-    //                ^^^^^^^^ must implement `IntoFieldError`
+        //            ^^^^^^^^ must implement `IntoFieldError`
         input
             .strip_prefix("id: ")
             .ok_or_else(|| {
@@ -130,7 +164,7 @@ impl UserId {
 # fn main() {}
 ```
 
-The provided function is polymorphic by input and output types:
+The provided function is polymorphic by its input and output types:
 ```rust
 # extern crate juniper;
 # use juniper::{GraphQLScalar, Scalar, ScalarValue};
@@ -169,7 +203,7 @@ Customization of which tokens a [custom GraphQL scalar][0] type should be parsed
 ```rust
 # extern crate juniper;
 # use juniper::{
-#     GraphQLScalar, ParseScalarResult, ParseScalarValue, Scalar, ScalarToken, ScalarValue, Value,
+#     GraphQLScalar, ParseScalarResult, ParseScalarValue, Scalar, ScalarToken, ScalarValue,
 # };
 #
 #[derive(GraphQLScalar)]
@@ -186,10 +220,12 @@ enum StringOrInt {
     Int(i32),
 }
 
-fn to_output<S: ScalarValue>(v: &StringOrInt) -> Value<S> {
+fn to_output<S: ScalarValue>(v: &StringOrInt) -> S {
     match v {
-        StringOrInt::String(s) => Value::scalar(s.to_owned()),
-        StringOrInt::Int(i) => Value::scalar(*i),
+        StringOrInt::String(s) => S::from_displayable(s),
+        //                        ^^^^^^^^^^^^^^^^^^^ preferable conversion for types
+        //                                            represented by string token
+        StringOrInt::Int(i) => (*i).into(),
     }
 }
 
@@ -216,7 +252,7 @@ Instead of providing all custom functions separately, it's possible to provide a
 ```rust
 # extern crate juniper;
 # use juniper::{
-#     GraphQLScalar, ParseScalarResult, ParseScalarValue, Scalar, ScalarToken, ScalarValue, Value,
+#     GraphQLScalar, ParseScalarResult, ParseScalarValue, Scalar, ScalarToken, ScalarValue,
 # };
 #
 #[derive(GraphQLScalar)]
@@ -229,10 +265,10 @@ enum StringOrInt {
 mod string_or_int {
     use super::*;
 
-    pub(super) fn to_output<S: ScalarValue>(v: &StringOrInt) -> Value<S> {
+    pub(super) fn to_output<S: ScalarValue>(v: &StringOrInt) -> S {
         match v {
-            StringOrInt::String(s) => Value::scalar(s.to_owned()),
-            StringOrInt::Int(i) => Value::scalar(*i),
+            StringOrInt::String(s) => S::from_displayable(s),
+            StringOrInt::Int(i) => (*i).into(),
         }
     }
 
@@ -256,7 +292,7 @@ A regular `impl` block is also suitable for that:
 ```rust
 # extern crate juniper;
 # use juniper::{
-#     GraphQLScalar, ParseScalarResult, ParseScalarValue, Scalar, ScalarToken, ScalarValue, Value,
+#     GraphQLScalar, ParseScalarResult, ParseScalarValue, Scalar, ScalarToken, ScalarValue,
 # };
 #
 #[derive(GraphQLScalar)]
@@ -267,10 +303,10 @@ enum StringOrInt {
 }
 
 impl StringOrInt {
-    fn to_output<S: ScalarValue>(&self) -> Value<S> {
+    fn to_output<S: ScalarValue>(&self) -> S {
         match self {
-            Self::String(s) => Value::scalar(s.to_owned()),
-            Self::Int(i) => Value::scalar(*i),
+            Self::String(s) => S::from_displayable(s),
+            Self::Int(i) => (*i).into(),
         }
     }
 
@@ -297,7 +333,7 @@ At the same time, any custom function still may be specified separately, if requ
 ```rust
 # extern crate juniper;
 # use juniper::{
-#     GraphQLScalar, ParseScalarResult, Scalar, ScalarToken, ScalarValue, Value,
+#     GraphQLScalar, ParseScalarResult, Scalar, ScalarToken, ScalarValue,
 # };
 #
 #[derive(GraphQLScalar)]
@@ -313,13 +349,10 @@ enum StringOrInt {
 mod string_or_int {
     use super::*;
 
-    pub(super) fn to_output<S>(v: &StringOrInt) -> Value<S>
-    where
-        S: ScalarValue,
-    {
+    pub(super) fn to_output<S: ScalarValue>(v: &StringOrInt) -> S {
         match v {
-            StringOrInt::String(s) => Value::scalar(s.to_owned()),
-            StringOrInt::Int(i) => Value::scalar(*i),
+            StringOrInt::String(s) => S::from_displayable(s),
+            StringOrInt::Int(i) => (*i).into(),
         }
     }
 
@@ -367,11 +400,12 @@ For implementing [custom scalars][2] on foreign types there is [`#[graphql_scala
 # }
 #
 # use juniper::DefaultScalarValue as CustomScalarValue;
-use juniper::{ScalarValue, Value, graphql_scalar};
+use juniper::{ScalarValue, graphql_scalar};
 
 #[graphql_scalar]
 #[graphql(
     with = date_scalar, 
+    to_output_with = ScalarValue::from_displayable, // use `Display` representation
     parse_token(String),
     scalar = CustomScalarValue,
 )]
@@ -381,10 +415,6 @@ type Date = date::Date;
 
 mod date_scalar {
     use super::*;
-  
-    pub(super) fn to_output(v: &Date) -> Value<CustomScalarValue> {
-        Value::scalar(v.to_string())
-    }
 
     pub(super) fn from_input(s: &str) -> Result<Date, Box<str>> {
         s.parse().map_err(|e| format!("Failed to parse `Date`: {e}").into())

juniper_codegen/Cargo.toml

@@ -31,7 +31,8 @@ url = "2.0"
 [dev-dependencies]
 derive_more = { version = "2.0", features = ["from", "try_into"] }
 futures = "0.3.22"
-juniper = { path = "../juniper" }
+jiff = { version = "0.2", features = ["std"], default-features = false }
+juniper = { path = "../juniper", features = ["jiff"] }
 serde = "1.0.122"
 
 [lints.clippy]