Codegen reimplementation for GraphQL unions

docs/book/tests/Cargo.toml

@@ -9,6 +9,8 @@ build = "build.rs"
 juniper = { path = "../../../juniper" }
 juniper_iron = { path = "../../../juniper_iron" }
 juniper_subscriptions = { path = "../../../juniper_subscriptions" }
+
+derive_more = "0.99.7"
 futures = "0.3"
 tokio = { version = "0.2", features = ["rt-core", "blocking", "stream", "rt-util"] }
 iron = "0.5.0"

integration_tests/codegen_fail/fail/union/derive_enum_field.stderr

@@ -1,3 +1,12 @@
+error[E0277]: the trait bound `Test: juniper::types::marker::GraphQLObjectType<juniper::value::scalar::DefaultScalarValue>` is not satisfied
+ --> $DIR/derive_enum_field.rs:7:10
+  |
+7 | #[derive(juniper::GraphQLUnion)]
+  |          ^^^^^^^^^^^^^^^^^^^^^ the trait `juniper::types::marker::GraphQLObjectType<juniper::value::scalar::DefaultScalarValue>` is not implemented for `Test`
+  |
+  = note: required by `juniper::types::marker::GraphQLObjectType::mark`
+  = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error[E0277]: the trait bound `Test: juniper::types::marker::GraphQLObjectType<__S>` is not satisfied
  --> $DIR/derive_enum_field.rs:7:10
   |

integration_tests/juniper_tests/Cargo.toml

@@ -1,12 +1,13 @@
 [package]
 name = "juniper_tests"
 version = "0.1.0"
-publish = false
 edition = "2018"
+publish = false
 
 [dependencies]
-juniper = { path = "../../juniper" }
+derive_more = "0.99.7"
 futures = "0.3.1"
+juniper = { path = "../../juniper" }
 
 [dev-dependencies]
 serde_json = { version = "1" }

integration_tests/juniper_tests/src/codegen/mod.rs

@@ -2,8 +2,8 @@ mod derive_enum;
 mod derive_input_object;
 mod derive_object;
 mod derive_object_with_raw_idents;
-mod derive_union;
 mod impl_object;
 mod impl_scalar;
-mod impl_union;
 mod scalar_value_transparent;
+mod union_attr;
+mod union_derive;

integration_tests/juniper_tests/src/codegen/union_attr.rs

@@ -0,0 +1,211 @@
+use std::any::Any;
+
+use juniper::{graphql_object, graphql_union, GraphQLObject};
+
+#[cfg(test)]
+use juniper::{
+    self, execute, DefaultScalarValue, EmptyMutation, EmptySubscription, GraphQLType, RootNode,
+    Value, Variables,
+};
+
+#[derive(GraphQLObject)]
+struct Human {
+    id: String,
+    home_planet: String,
+}
+
+#[derive(GraphQLObject)]
+struct Droid {
+    id: String,
+    primary_function: String,
+}
+
+#[derive(GraphQLObject)]
+struct Jedi {
+    id: String,
+    rank: String,
+}
+
+#[graphql_union(name = "Character")]
+#[graphql_union(description = "A Collection of things")]
+#[graphql_union(on Jedi = resolve_character_jedi)]
+trait Character<T> {
+    fn as_human(&self, _: &()) -> Option<&Human> {
+        None
+    }
+    fn as_droid(&self) -> Option<&Droid> {
+        None
+    }
+    #[graphql_union(ignore)]
+    fn as_jedi(&self) -> Option<&Jedi> {
+        None
+    }
+    #[graphql_union(ignore)]
+    fn some(&self) {}
+}
+
+impl<T> Character<T> for Human {
+    fn as_human(&self, _: &()) -> Option<&Human> {
+        Some(&self)
+    }
+}
+
+impl<T> Character<T> for Droid {
+    fn as_droid(&self) -> Option<&Droid> {
+        Some(&self)
+    }
+}
+
+impl<T> Character<T> for Jedi {
+    fn as_jedi(&self) -> Option<&Jedi> {
+        Some(&self)
+    }
+}
+
+fn resolve_character_jedi<'a, T>(
+    jedi: &'a (dyn Character<T> + Send + Sync),
+    _: &(),
+) -> Option<&'a Jedi> {
+    jedi.as_jedi()
+}
+
+enum Query {
+    Human,
+    Droid,
+    Jedi,
+}
+
+#[graphql_object]
+impl Query {
+    fn context(&self) -> Box<dyn Character<()> + Send + Sync> {
+        let ch: Box<dyn Character<()> + Send + Sync> = match self {
+            Self::Human => Box::new(Human {
+                id: "human-32".to_string(),
+                home_planet: "earth".to_string(),
+            }),
+            Self::Droid => Box::new(Droid {
+                id: "droid-99".to_string(),
+                primary_function: "run".to_string(),
+            }),
+            Self::Jedi => Box::new(Jedi {
+                id: "Obi Wan Kenobi".to_string(),
+                rank: "Master".to_string(),
+            }),
+        };
+        ch
+    }
+}
+
+const DOC: &str = r#"
+{
+    context {
+        ... on Human {
+            humanId: id
+            homePlanet
+        }
+        ... on Droid {
+            droidId: id
+            primaryFunction
+        }
+        ... on Jedi {
+            jediId: id
+            rank
+        }
+    }
+}"#;
+
+#[tokio::test]
+async fn resolves_human() {
+    let schema = RootNode::new(
+        Query::Human,
+        EmptyMutation::<()>::new(),
+        EmptySubscription::<()>::new(),
+    );
+
+    let actual = execute(DOC, None, &schema, &Variables::new(), &()).await;
+
+    let expected = Ok((
+        Value::object(
+            vec![(
+                "context",
+                Value::object(
+                    vec![
+                        ("humanId", Value::scalar("human-32".to_string())),
+                        ("homePlanet", Value::scalar("earth".to_string())),
+                    ]
+                    .into_iter()
+                    .collect(),
+                ),
+            )]
+            .into_iter()
+            .collect(),
+        ),
+        vec![],
+    ));
+
+    assert_eq!(actual, expected);
+}
+
+#[tokio::test]
+async fn resolves_droid() {
+    let schema = RootNode::new(
+        Query::Droid,
+        EmptyMutation::<()>::new(),
+        EmptySubscription::<()>::new(),
+    );
+
+    let actual = execute(DOC, None, &schema, &Variables::new(), &()).await;
+
+    let expected = Ok((
+        Value::object(
+            vec![(
+                "context",
+                Value::object(
+                    vec![
+                        ("droidId", Value::scalar("droid-99".to_string())),
+                        ("primaryFunction", Value::scalar("run".to_string())),
+                    ]
+                    .into_iter()
+                    .collect(),
+                ),
+            )]
+            .into_iter()
+            .collect(),
+        ),
+        vec![],
+    ));
+
+    assert_eq!(actual, expected);
+}
+
+#[tokio::test]
+async fn resolves_jedi() {
+    let schema = RootNode::new(
+        Query::Jedi,
+        EmptyMutation::<()>::new(),
+        EmptySubscription::<()>::new(),
+    );
+
+    let actual = execute(DOC, None, &schema, &Variables::new(), &()).await;
+
+    let expected = Ok((
+        Value::object(
+            vec![(
+                "context",
+                Value::object(
+                    vec![
+                        ("jediId", Value::scalar("Obi Wan Kenobi".to_string())),
+                        ("rank", Value::scalar("Master".to_string())),
+                    ]
+                    .into_iter()
+                    .collect(),
+                ),
+            )]
+            .into_iter()
+            .collect(),
+        ),
+        vec![],
+    ));
+
+    assert_eq!(actual, expected);
+}