Add integration for serde_json::Value

README.md

@@ -65,6 +65,7 @@ your Schemas automatically.
 - [uuid][uuid]
 - [url][url]
 - [chrono][chrono]
+- [serde_json][serde_json]
 
 ### Web Frameworks
 
@@ -101,3 +102,4 @@ Juniper has not reached 1.0 yet, thus some API instability should be expected.
 [uuid]: https://crates.io/crates/uuid
 [url]: https://crates.io/crates/url
 [chrono]: https://crates.io/crates/chrono
+[serde_json]: https://crates.io/crates/serde_json

juniper/CHANGELOG.md

@@ -6,6 +6,11 @@
   The DirectiveLocation::InlineFragment had an invalid literal value,
   which broke third party tools like apollo cli.
 - Added GraphQL Playground integration
+- Added built-in integration for [`serde_json::Value`](https://docs.serde.rs/serde_json/value).
+  `serde_json::Value` will serialize and deserialize as a
+  GraphQL scalar `String` named `JsonString`, as GraphQL [does not
+  support a Map type](https://github.com/facebook/graphql/issues/101).
+  The integration can be controlled via the `json` feature.
 
 # [0.11.1] 2018-12-19
 

juniper/Cargo.toml

@@ -24,8 +24,10 @@ path = "benches/bench.rs"
 [features]
 nightly = []
 expose-test-schema = []
+json = ["serde_json"]
 default = [
     "chrono",
+    "json",
     "url",
     "uuid",
 ]

juniper/src/integrations/json.rs

@@ -0,0 +1,106 @@
+use serde_json::Value as JsonValue;
+
+use parser::{ParseError, ScalarToken, Token};
+use value::ParseScalarResult;
+use Value;
+
+graphql_scalar!(JsonValue as "JsonString" where Scalar = <S> {
+    description: "JSON serialized as a string"
+
+    resolve(&self) -> Value {
+        Value::scalar(self.to_string())
+    }
+
+    from_input_value(v: &InputValue) -> Option<JsonValue> {
+        v.as_scalar_value::<String>()
+         .and_then(|s| serde_json::from_str(s).ok())
+    }
+
+    from_str<'a>(value: ScalarToken<'a>) -> ParseScalarResult<'a, S> {
+        if let ScalarToken::String(value) = value {
+            Ok(S::from(value.to_owned()))
+        } else {
+            Err(ParseError::UnexpectedToken(Token::Scalar(value)))
+        }
+    }
+});
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn json_from_input_value() {
+        let raw = r#"{ "foo": "bar"}"#;
+        let input: ::InputValue = ::InputValue::scalar(raw.to_string());
+
+        let parsed: JsonValue = ::FromInputValue::from_input_value(&input).unwrap();
+        let expected: JsonValue = serde_json::from_str(raw).unwrap();
+
+        assert_eq!(parsed, expected);
+    }
+
+}
+
+#[cfg(test)]
+mod integration_test {
+    use super::*;
+
+    use executor::Variables;
+    use schema::model::RootNode;
+    use types::scalars::EmptyMutation;
+    use value::Value;
+
+    #[test]
+    fn test_json_serialization() {
+        let example_raw: JsonValue = serde_json::from_str(
+            r#"{
+            "x": 2,
+            "y": 42
+            }
+        "#,
+        )
+        .unwrap();
+        let example_raw = example_raw.to_string();
+
+        struct Root;
+        graphql_object!(Root: () |&self| {
+            field example_json() -> JsonValue {
+                serde_json::from_str(r#"{
+                    "x": 2,
+                    "y": 42
+                    }
+                "#).unwrap()
+            }
+            field input_json(input: JsonValue) -> bool {
+                input.is_array()
+            }
+        });
+
+        let doc = r#"
+        {
+            exampleJson,
+            inputJson(input: "[]"),
+        }
+        "#;
+
+        let schema = RootNode::new(Root, EmptyMutation::<()>::new());
+
+        let (result, errs) =
+            ::execute(doc, None, &schema, &Variables::new(), &()).expect("Execution failed");
+
+        assert_eq!(errs, []);
+
+        assert_eq!(
+            result,
+            Value::object(
+                vec![
+                    ("exampleJson", Value::scalar(example_raw)),
+                    ("inputJson", Value::scalar(true)),
+                ]
+                .into_iter()
+                .collect()
+            )
+        );
+    }
+}

juniper/src/integrations/mod.rs

@@ -6,6 +6,10 @@ pub mod serde;
 /// GraphQL support for [chrono](https://github.com/chronotope/chrono) types.
 pub mod chrono;
 
+#[cfg(feature = "json")]
+/// GraphQL support for [serde_json::Value](https://docs.serde.rs/serde_json/value/enum.Value.html) types.
+pub mod json;
+
 #[cfg(feature = "url")]
 /// GraphQL support for [url](https://github.com/servo/rust-url) types.
 pub mod url;

juniper/src/lib.rs

@@ -96,7 +96,7 @@ pub extern crate serde;
 #[macro_use]
 extern crate serde_derive;
 
-#[cfg(any(test, feature = "expose-test-schema"))]
+#[cfg(any(test, feature = "json", feature = "expose-test-schema"))]
 extern crate serde_json;
 
 extern crate fnv;