move validation check to Query struct

Added Leaf-Field-Selections rule

Author: dotansimha

Cargo.lock

@@ -1,4 +1,5 @@
 use graphql_parser::Pos;
+use graphql_tools::validation::utils::ValidationError;
 use hex::FromHexError;
 use num_bigint;
 use serde::ser::*;
@@ -297,6 +298,12 @@ impl From<QueryExecutionError> for Vec<QueryExecutionError> {
     }
 }
 
+impl From<ValidationError> for QueryExecutionError {
+    fn from(e: ValidationError) -> Self {
+        QueryExecutionError::ValidationError(e.locations.clone().into_iter().nth(0), e.message)
+    }
+}
+
 impl From<FromHexError> for QueryExecutionError {
     fn from(e: FromHexError) -> Self {
         QueryExecutionError::ValueParseError("Bytes".to_string(), e.to_string())

graph/src/data/query/error.rs

@@ -1,6 +1,5 @@
 use super::error::{QueryError, QueryExecutionError};
 use crate::prelude::{r, CacheWeight, DeploymentHash};
-use graphql_tools::validation::utils::ValidationError;
 use http::header::{
     ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
     CONTENT_TYPE,
@@ -183,7 +182,6 @@ pub struct QueryResult {
     data: Option<Data>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     errors: Vec<QueryError>,
-    /// This is a non-standard GraphQL response field.
     #[serde(skip_serializing)]
     pub deployment: Option<DeploymentHash>,
 }
@@ -252,26 +250,6 @@ impl From<QueryExecutionError> for QueryResult {
     }
 }
 
-impl From<Vec<ValidationError>> for QueryResult {
-    fn from(errors: Vec<ValidationError>) -> Self {
-        let execution_errors = errors
-            .iter()
-            .map(|e| {
-                QueryError::ExecutionError(QueryExecutionError::ValidationError(
-                    e.locations.clone().into_iter().nth(0),
-                    e.message.clone(),
-                ))
-            })
-            .collect::<Vec<QueryError>>();
-
-        QueryResult {
-            data: None,
-            errors: execution_errors,
-            deployment: None,
-        }
-    }
-}
-
 impl From<QueryError> for QueryResult {
     fn from(e: QueryError) -> Self {
         QueryResult {

graph/src/data/query/result.rs

@@ -8,7 +8,7 @@ crossbeam = "0.8"
 futures01 = { package="futures", version="0.1.29" }
 graph = { path = "../graph" }
 graphql-parser = "0.4.0"
-graphql-tools = "0.0.6"
+graphql-tools = "0.0.8"
 indexmap = "1.7"
 Inflector = "0.11.3"
 lazy_static = "1.2.0"

graphql/Cargo.toml

@@ -1,4 +1,5 @@
 use graphql_parser::Pos;
+use graphql_tools::validation::validate::{validate, ValidationPlan};
 use std::collections::{HashMap, HashSet};
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
@@ -112,9 +113,19 @@ impl Query {
         schema: Arc<ApiSchema>,
         network: Option<String>,
         query: GraphDataQuery,
+        validation_plan: Arc<ValidationPlan>,
         max_complexity: Option<u64>,
         max_depth: u8,
     ) -> Result<Arc<Self>, Vec<QueryExecutionError>> {
+        let validation_errors = validate(&schema.document(), &query.document, &validation_plan);
+
+        if validation_errors.len() > 0 {
+            return Err(validation_errors
+                .into_iter()
+                .map(|e| QueryExecutionError::from(e))
+                .collect());
+        }
+
         let mut operation = None;
         let mut fragments = HashMap::new();
         for defn in query.document.definitions.into_iter() {

graphql/src/execution/query.rs

@@ -7,7 +7,7 @@ use std::time::{Duration, Instant};
 use crate::prelude::{QueryExecutionOptions, StoreResolver, SubscriptionExecutionOptions};
 use crate::query::execute_query;
 use crate::subscription::execute_prepared_subscription;
-use graph::prelude::{MetricsRegistry, QueryResult};
+use graph::prelude::MetricsRegistry;
 use graph::prometheus::{Gauge, Histogram};
 use graph::{
     components::store::SubscriptionManager,
@@ -22,10 +22,10 @@ use graph::{
     prelude::QueryStore,
 };
 use graphql_tools::validation::rules::{
-    FragmentsOnCompositeTypes, KnownFragmentNamesRule, LoneAnonymousOperation, NoUnusedFragments,
-    OverlappingFieldsCanBeMerged,
+    FragmentsOnCompositeTypes, KnownFragmentNamesRule, LeafFieldSelections, LoneAnonymousOperation,
+    NoUnusedFragments, OverlappingFieldsCanBeMerged,
 };
-use graphql_tools::validation::validate::{validate, ValidationPlan};
+use graphql_tools::validation::validate::ValidationPlan;
 
 use lazy_static::lazy_static;
 
@@ -82,7 +82,7 @@ pub struct GraphQlRunner<S, SM> {
     subscription_manager: Arc<SM>,
     load_manager: Arc<LoadManager>,
     result_size: Arc<ResultSizeMetrics>,
-    graphql_validation_plan: ValidationPlan,
+    pub graphql_validation_plan: Arc<ValidationPlan>,
 }
 
 lazy_static! {
@@ -148,14 +148,15 @@ where
         graphql_validation_plan.add_rule(Box::new(OverlappingFieldsCanBeMerged {}));
         graphql_validation_plan.add_rule(Box::new(KnownFragmentNamesRule {}));
         graphql_validation_plan.add_rule(Box::new(NoUnusedFragments {}));
+        graphql_validation_plan.add_rule(Box::new(LeafFieldSelections {}));
 
         GraphQlRunner {
             logger,
             store,
             subscription_manager,
             load_manager,
             result_size,
-            graphql_validation_plan,
+            graphql_validation_plan: Arc::new(graphql_validation_plan),
         }
     }
 
@@ -210,17 +211,6 @@ where
         // setting up here
         let store = self.store.query_store(target, false).await?;
         let schema = store.api_schema()?;
-
-        let validation_errors = validate(
-            &schema.document(),
-            &query.document,
-            &self.graphql_validation_plan,
-        );
-
-        if validation_errors.len() > 0 {
-            return Ok(QueryResults::from(QueryResult::from(validation_errors)));
-        }
-
         let state = store.deployment_state().await?;
         let network = Some(store.network_name().to_string());
 
@@ -238,6 +228,7 @@ where
             schema,
             network,
             query,
+            self.graphql_validation_plan.clone(),
             max_complexity,
             max_depth,
         )?;
@@ -343,6 +334,7 @@ where
             schema,
             Some(network.clone()),
             subscription.query,
+            self.graphql_validation_plan.clone(),
             *GRAPHQL_MAX_COMPLEXITY,
             *GRAPHQL_MAX_DEPTH,
         )?;

graphql/src/runner.rs

@@ -5,6 +5,7 @@ use std::time::{Duration, Instant};
 
 use graph::components::store::UnitStream;
 use graph::{components::store::SubscriptionManager, prelude::*};
+use graphql_tools::validation::validate::ValidationPlan;
 
 use crate::runner::ResultSizeMetrics;
 use crate::{
@@ -51,6 +52,7 @@ pub fn execute_subscription(
         schema,
         None,
         subscription.query,
+        Arc::new(ValidationPlan { rules: vec![] }),
         options.max_complexity,
         options.max_depth,
     )?;

graphql/src/subscription/mod.rs

@@ -14,3 +14,4 @@ http = "0.2"
 hyper = "0.14"
 serde = "1.0"
 either = "1.6.1"
+graphql-tools = "0.0.8"

server/index-node/Cargo.toml

@@ -1,3 +1,4 @@
+use graphql_tools::validation::validate::ValidationPlan;
 use http::header::{
     self, ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
     CONTENT_TYPE, LOCATION,
@@ -113,7 +114,15 @@ where
             .await?;
 
         let query = IndexNodeRequest::new(body).compat().await?;
-        let query = match PreparedQuery::new(&self.logger, schema, None, query, None, 100) {
+        let query = match PreparedQuery::new(
+            &self.logger,
+            schema,
+            None,
+            query,
+            Arc::new(ValidationPlan { rules: vec![] }),
+            None,
+            100,
+        ) {
             Ok(query) => query,
             Err(e) => return Ok(QueryResults::from(QueryResult::from(e)).as_http_response()),
         };

server/index-node/src/service.rs

@@ -16,3 +16,4 @@ lazy_static = "1.1"
 hex-literal = "0.3"
 diesel = { version = "1.4.8", features = ["postgres", "serde_json", "numeric", "r2d2"] }
 graph-chain-ethereum = { path = "../../chain/ethereum" }
+graphql-tools = "0.0.8"