Refactor GraphQL execution

core/tests/interfaces.rs

@@ -67,7 +67,8 @@ async fn one_interface_zero_entities() {
         .unwrap();
 
     let data = extract_data!(res).unwrap();
-    assert_eq!(format!("{:?}", data), "Object({\"leggeds\": List([])})")
+    let exp = object! { leggeds: Vec::<r::Value>::new() };
+    assert_eq!(data, exp);
 }
 
 #[tokio::test]
@@ -87,21 +88,17 @@ async fn one_interface_one_entity() {
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        "Object({\"leggeds\": List([Object({\"legs\": Int(3)})])})"
-    );
+    let exp = object! { leggeds: vec![ object!{ legs: 3 }]};
+    assert_eq!(data, exp);
 
     // Query by ID.
     let query = "query { legged(id: \"1\") { legs } }";
     let res = insert_and_query(subgraph_id, schema, vec![], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        "Object({\"legged\": Object({\"legs\": Int(3)})})",
-    );
+    let exp = object! { legged: object! { legs: 3 }};
+    assert_eq!(data, exp);
 }
 
 #[tokio::test]
@@ -121,10 +118,8 @@ async fn one_interface_one_entity_typename() {
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        "Object({\"leggeds\": List([Object({\"__typename\": String(\"Animal\")})])})"
-    )
+    let exp = object! { leggeds: vec![ object!{ __typename: "Animal" } ]};
+    assert_eq!(data, exp);
 }
 
 #[tokio::test]
@@ -150,21 +145,17 @@ async fn one_interface_multiple_entities() {
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        "Object({\"leggeds\": List([Object({\"legs\": Int(3)}), Object({\"legs\": Int(4)})])})"
-    );
+    let exp = object! { leggeds: vec![ object! { legs: 3 }, object! { legs: 4 }]};
+    assert_eq!(data, exp);
 
     // Test for support issue #32.
     let query = "query { legged(id: \"2\") { legs } }";
     let res = insert_and_query(subgraph_id, schema, vec![], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        "Object({\"legged\": Object({\"legs\": Int(4)})})",
-    );
+    let exp = object! { legged: object! { legs: 4 }};
+    assert_eq!(data, exp);
 }
 
 #[tokio::test]
@@ -187,10 +178,8 @@ async fn reference_interface() {
         .unwrap();
 
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        "Object({\"leggeds\": List([Object({\"leg\": Object({\"id\": String(\"1\")})})])})"
-    )
+    let exp = object! { leggeds: vec![ object!{ leg: object! { id: "1" } }] };
+    assert_eq!(data, exp);
 }
 
 #[tokio::test]
@@ -253,13 +242,15 @@ async fn reference_interface_derived() {
         .unwrap();
 
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        "Object({\"events\": List([\
-            Object({\"id\": String(\"buy\"), \"transaction\": Object({\"id\": String(\"txn\")})}), \
-            Object({\"id\": String(\"gift\"), \"transaction\": Object({\"id\": String(\"txn\")})}), \
-            Object({\"id\": String(\"sell1\"), \"transaction\": Object({\"id\": String(\"txn\")})}), \
-            Object({\"id\": String(\"sell2\"), \"transaction\": Object({\"id\": String(\"txn\")})})])})");
+    let exp = object! {
+        events: vec![
+            object! { id: "buy", transaction: object! { id: "txn" } },
+            object! { id: "gift", transaction: object! { id: "txn" } },
+            object! { id: "sell1", transaction: object! { id: "txn" } },
+            object! { id: "sell2", transaction: object! { id: "txn" } }
+        ]
+    };
+    assert_eq!(data, exp);
 }
 
 #[tokio::test]
@@ -278,14 +269,20 @@ async fn follow_interface_reference_invalid() {
         .await
         .unwrap();
 
+    // Depending on whether `ENABLE_GRAPHQL_VALIDATIONS` is set or not, we
+    // get different errors
     match &res.to_result().unwrap_err()[0] {
         QueryError::ExecutionError(QueryExecutionError::ValidationError(_, error_message)) => {
             assert_eq!(
                 error_message,
                 "Cannot query field \"parent\" on type \"Legged\"."
             );
         }
-        e => panic!("error {} is not the expected one", e),
+        QueryError::ExecutionError(QueryExecutionError::UnknownField(_, type_name, field_name)) => {
+            assert_eq!(type_name, "Legged");
+            assert_eq!(field_name, "parent");
+        }
+        e => panic!("error `{}` is not the expected one", e),
     }
 }
 
@@ -323,10 +320,10 @@ async fn follow_interface_reference() {
         .unwrap();
 
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        "Object({\"legged\": Object({\"parent\": Object({\"id\": String(\"parent\")})})})"
-    )
+    let exp = object! {
+        legged: object! { parent: object! { id: "parent" } }
+    };
+    assert_eq!(data, exp)
 }
 
 #[tokio::test]
@@ -426,11 +423,11 @@ async fn two_interfaces() {
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        "Object({\"ibars\": List([Object({\"bar\": Int(100)}), Object({\"bar\": Int(200)})]), \
-                 \"ifoos\": List([Object({\"foo\": String(\"bla\")}), Object({\"foo\": String(\"ble\")})])})"
-    );
+    let exp = object! {
+        ibars: vec![ object! { bar: 100 }, object! { bar: 200 }],
+        ifoos: vec![ object! { foo: "bla" }, object! { foo: "ble" } ]
+    };
+    assert_eq!(data, exp);
 }
 
 #[tokio::test]
@@ -454,21 +451,17 @@ async fn interface_non_inline_fragment() {
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        r#"Object({"leggeds": List([Object({"name": String("cow")})])})"#
-    );
+    let exp = object! { leggeds: vec![ object! { name: "cow" } ]};
+    assert_eq!(data, exp);
 
     // Query the fragment and something else.
     let query = "query { leggeds { legs, ...frag } } fragment frag on Animal { name }";
     let res = insert_and_query(subgraph_id, schema, vec![], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        r#"Object({"leggeds": List([Object({"legs": Int(3), "name": String("cow")})])})"#,
-    );
+    let exp = object! { leggeds: vec![ object!{ legs: 3, name: "cow" } ]};
+    assert_eq!(data, exp);
 }
 
 #[tokio::test]
@@ -501,10 +494,8 @@ async fn interface_inline_fragment() {
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
-    assert_eq!(
-        format!("{:?}", data),
-        r#"Object({"leggeds": List([Object({"airspeed": Int(24)}), Object({"name": String("cow")})])})"#
-    );
+    let exp = object! { leggeds: vec![ object!{ airspeed: 24 }, object! { name: "cow" }]};
+    assert_eq!(data, exp);
 }
 
 #[tokio::test]
@@ -567,20 +558,11 @@ async fn interface_inline_fragment_with_subquery() {
     .await
     .unwrap();
     let data = extract_data!(res).unwrap();
-
-    assert_eq!(
-        format!("{:?}", data),
-        "Object({\
-         \"leggeds\": List([\
-         Object({\
-         \"airspeed\": Int(5), \
-         \"legs\": Int(2), \
-         \"parent\": Object({\"id\": String(\"mama_bird\")})\
-         }), \
-         Object({\"legs\": Int(4)})\
-         ])\
-         })"
-    );
+    let exp = object! {
+        leggeds: vec![ object!{ legs: 2, airspeed: 5, parent: object! { id: "mama_bird" } },
+                       object!{ legs: 4 }]
+    };
+    assert_eq!(data, exp);
 }
 
 #[tokio::test]
@@ -1394,6 +1376,16 @@ async fn enum_list_filters() {
 
 #[tokio::test]
 async fn recursive_fragment() {
+    // Depending on whether `ENABLE_GRAPHQL_VALIDATIONS` is set or not, we
+    // get different error messages
+    const FOO_ERRORS: [&str; 2] = [
+        "Cannot spread fragment \"FooFrag\" within itself.",
+        "query has fragment cycle including `FooFrag`",
+    ];
+    const FOO_BAR_ERRORS: [&str; 2] = [
+        "Cannot spread fragment \"BarFrag\" within itself via \"FooFrag\".",
+        "query has fragment cycle including `BarFrag`",
+    ];
     let subgraph_id = "RecursiveFragment";
     let schema = "
         type Foo @entity {
@@ -1426,7 +1418,7 @@ async fn recursive_fragment() {
         .await
         .unwrap();
     let data = res.to_result().unwrap_err()[0].to_string();
-    assert_eq!(data, "Cannot spread fragment \"FooFrag\" within itself.");
+    assert!(FOO_ERRORS.contains(&data.as_str()));
 
     let co_recursive = "
         query {
@@ -1453,8 +1445,5 @@ async fn recursive_fragment() {
         .await
         .unwrap();
     let data = res.to_result().unwrap_err()[0].to_string();
-    assert_eq!(
-        data,
-        "Cannot spread fragment \"BarFrag\" within itself via \"FooFrag\"."
-    );
+    assert!(FOO_BAR_ERRORS.contains(&data.as_str()));
 }

graph/src/components/store.rs

@@ -1713,12 +1713,11 @@ impl AttributeNames {
         }
     }
 
-    /// Adds a attribute name. Ignores meta fields.
-    pub fn add(&mut self, field: &q::Field) {
-        if Self::is_meta_field(&field.name) {
+    pub fn update(&mut self, field_name: &str) {
+        if Self::is_meta_field(field_name) {
             return;
         }
-        self.insert(&field.name)
+        self.insert(&field_name)
     }
 
     /// Adds a attribute name. Ignores meta fields.

graph/src/data/graphql/ext.rs

@@ -66,6 +66,13 @@ pub trait DocumentExt {
     fn get_named_type(&self, name: &str) -> Option<&TypeDefinition>;
 
     fn scalar_value_type(&self, field_type: &Type) -> ValueType;
+
+    /// Return `true` if the type does not allow selection of child fields.
+    ///
+    /// # Panics
+    ///
+    /// If `field_type` names an unknown type
+    fn is_leaf_type(&self, field_type: &Type) -> bool;
 }
 
 impl DocumentExt for Document {
@@ -219,6 +226,19 @@ impl DocumentExt for Document {
             Type::ListType(inner) => self.scalar_value_type(inner),
         }
     }
+
+    fn is_leaf_type(&self, field_type: &Type) -> bool {
+        match self
+            .get_named_type(field_type.get_base_type())
+            .expect("names of field types have been validated")
+        {
+            TypeDefinition::Enum(_) | TypeDefinition::Scalar(_) => true,
+            TypeDefinition::Object(_)
+            | TypeDefinition::Interface(_)
+            | TypeDefinition::Union(_)
+            | TypeDefinition::InputObject(_) => false,
+        }
+    }
 }
 
 pub trait TypeExt {
@@ -348,6 +368,41 @@ impl DirectiveFinder for Vec<Directive> {
     }
 }
 
+pub trait TypeDefinitionExt {
+    fn name(&self) -> &str;
+
+    // Return `true` if this is the definition of a type from the
+    // introspection schema
+    fn is_introspection(&self) -> bool {
+        self.name().starts_with("__")
+    }
+}
+
+impl TypeDefinitionExt for TypeDefinition {
+    fn name(&self) -> &str {
+        match self {
+            TypeDefinition::Scalar(t) => &t.name,
+            TypeDefinition::Object(t) => &t.name,
+            TypeDefinition::Interface(t) => &t.name,
+            TypeDefinition::Union(t) => &t.name,
+            TypeDefinition::Enum(t) => &t.name,
+            TypeDefinition::InputObject(t) => &t.name,
+        }
+    }
+}
+
+pub trait FieldExt {
+    // Return `true` if this is the name of one of the query fields from the
+    // introspection schema
+    fn is_introspection(&self) -> bool;
+}
+
+impl FieldExt for Field {
+    fn is_introspection(&self) -> bool {
+        &self.name == "__schema" || &self.name == "__type"
+    }
+}
+
 #[cfg(test)]
 mod directive_finder_tests {
     use graphql_parser::parse_schema;

graph/src/data/graphql/object_macro.rs

@@ -1,13 +1,13 @@
+use crate::data::value::Object;
 use crate::prelude::q;
 use crate::prelude::r;
-use std::collections::BTreeMap;
 use std::iter::FromIterator;
 
 /// Creates a `graphql_parser::query::Value::Object` from key/value pairs.
 /// If you don't need to determine which keys are included dynamically at runtime
 /// consider using the `object! {}` macro instead.
 pub fn object_value(data: Vec<(&str, r::Value)>) -> r::Value {
-    r::Value::Object(BTreeMap::from_iter(
+    r::Value::Object(Object::from_iter(
         data.into_iter().map(|(k, v)| (k.to_string(), v)),
     ))
 }
@@ -83,12 +83,12 @@ macro_rules! impl_into_values {
 
 impl_into_values![(String, String), (f64, Float), (bool, Boolean)];
 
-/// Creates a `graphql_parser::query::Value::Object` from key/value pairs.
+/// Creates a `data::value::Value::Object` from key/value pairs.
 #[macro_export]
 macro_rules! object {
     ($($name:ident: $value:expr,)*) => {
         {
-            let mut result = ::std::collections::BTreeMap::new();
+            let mut result = $crate::data::value::Object::new();
             $(
                 let value = $crate::data::graphql::object_macro::IntoValue::into_value($value);
                 result.insert(stringify!($name).to_string(), value);