chore: refactor subgraph check

This commit does a lot of heavy lifting for the pending rebase.

1) Creates new input and output types in rover-client for subgraph check
2) Moves GitContext out of rover::utils to rover-client::utils
3) Creates error code E029 for composition errors
4) Styles cloud-composition errors like harmonizer

Author: EverlastingBugstopper

Cargo.lock

@@ -14,6 +14,8 @@ houston = {path = "../houston"}
 anyhow = "1"
 camino = "1"
 chrono = "0.4"
+git-url-parse = "0.3.1"
+git2 = { version = "0.13.20", default-features = false, features = ["vendored-openssl"] }
 graphql-parser = "0.3.0"
 graphql_client = "0.9"
 http = "0.2"

crates/rover-client/Cargo.toml

@@ -1,6 +1,8 @@
 use reqwest::Url;
 use thiserror::Error;
 
+use crate::query::subgraph::check::types::CompositionError;
+
 /// RoverClientError represents all possible failures that can occur during a client request.
 #[derive(Error, Debug)]
 pub enum RoverClientError {
@@ -104,6 +106,12 @@ pub enum RoverClientError {
         composition_errors: Vec<String>,
     },
 
+    #[error("{}", subgraph_composition_error_msg(.composition_errors))]
+    SubgraphCompositionErrors {
+        graph_name: String,
+        composition_errors: Vec<CompositionError>,
+    },
+
     /// This error occurs when the Studio API returns no implementing services for a graph
     /// This response shouldn't be possible!
     #[error("The response from Apollo Studio was malformed. Response body contains `null` value for \"{null_field}\"")]
@@ -141,3 +149,19 @@ pub enum RoverClientError {
     #[error("This endpoint doesn't support subgraph introspection via the Query._service field")]
     SubgraphIntrospectionNotAvailable,
 }
+
+fn subgraph_composition_error_msg(composition_errors: &[CompositionError]) -> String {
+    let num_failures = composition_errors.len();
+    if num_failures == 0 {
+        unreachable!("No composition errors were encountered while composing the supergraph.");
+    }
+    let mut msg = String::new();
+    msg.push_str(&match num_failures {
+        1 => "Encountered 1 composition error while composing the supergraph.".to_string(),
+        _ => format!(
+            "Encountered {} composition errors while composing the supergraph.",
+            num_failures
+        ),
+    });
+    msg
+}

crates/rover-client/src/error.rs

@@ -21,3 +21,6 @@ pub mod query;
 
 /// Module for getting release info
 pub mod releases;
+
+/// Module for shared functionality
+pub mod utils;

crates/rover-client/src/lib.rs

@@ -1,22 +1,27 @@
-  mutation CheckPartialSchemaQuery(
+  mutation SubgraphCheckQuery(
     $graph_id: ID!
     $variant: String!
-    $implementingServiceName: String!
-    $partialSchema: PartialSchemaInput!
-    $gitContext: GitContextInput!
+    $subgraph: String!
+    $proposed_schema: PartialSchemaInput!
+    $git_context: GitContextInput!
     $config: HistoricQueryParameters!
   ) {
     service(id: $graph_id) {
       checkPartialSchema(
         graphVariant: $variant
-        implementingServiceName: $implementingServiceName
-        partialSchema: $partialSchema
-        gitContext: $gitContext
+        implementingServiceName: $subgraph
+        partialSchema: $proposed_schema
+        gitContext: $git_context
         historicParameters: $config
       ) {
         compositionValidationResult {
           errors {
             message
+            code
+            locations {
+              line
+              column
+            }
           }
         }
         checkSchemaResult {

crates/rover-client/src/query/subgraph/check.graphql crates/rover-client/src/query/subgraph/check/check_query.graphql

@@ -0,0 +1,3 @@
+pub mod query_runner;
+pub(crate) mod types;
+pub use types::{SubgraphCheckConfig, SubgraphCheckInput, SubgraphCheckResponse};

crates/rover-client/src/query/subgraph/check/mod.rs

@@ -1,39 +1,36 @@
+use super::types::*;
 use crate::blocking::StudioClient;
 use crate::query::config::is_federated;
 use crate::RoverClientError;
-
 use graphql_client::*;
 
-use reqwest::Url;
-
-type Timestamp = String;
 #[derive(GraphQLQuery)]
 // The paths are relative to the directory where your `Cargo.toml` is located.
 // Both json and the GraphQL schema language are supported as sources for the schema
 #[graphql(
-    query_path = "src/query/subgraph/check.graphql",
+    query_path = "src/query/subgraph/check/check_query.graphql",
     schema_path = ".schema/schema.graphql",
     response_derives = "PartialEq, Debug, Serialize, Deserialize",
     deprecated = "warn"
 )]
 /// This struct is used to generate the module containing `Variables` and
 /// `ResponseData` structs.
-/// Snake case of this name is the mod name. i.e. check_partial_schema_query
-pub struct CheckPartialSchemaQuery;
+/// Snake case of this name is the mod name. i.e. subgraph_check_query
+pub struct SubgraphCheckQuery;
 
 /// The main function to be used from this module.
 /// This function takes a proposed schema and validates it against a published
 /// schema.
 pub fn run(
-    variables: check_partial_schema_query::Variables,
+    input: SubgraphCheckInput,
     client: &StudioClient,
-) -> Result<CheckResponse, RoverClientError> {
-    let graph = variables.graph_id.clone();
+) -> Result<SubgraphCheckResponse, RoverClientError> {
+    let graph = input.graph_id.clone();
     // This response is used to check whether or not the current graph is federated.
     let is_federated = is_federated::run(
         is_federated::is_federated_graph::Variables {
-            graph_id: variables.graph_id.clone(),
-            graph_variant: variables.variant.clone(),
+            graph_id: input.graph_id.clone(),
+            graph_variant: input.variant.clone(),
         },
         &client,
     )?;
@@ -43,77 +40,71 @@ pub fn run(
             can_operation_convert: false,
         });
     }
-    let data = client.post::<CheckPartialSchemaQuery>(variables)?;
+    let variables = input.into();
+    let data = client.post::<SubgraphCheckQuery>(variables)?;
     get_check_response_from_data(data, graph)
 }
 
-pub enum CheckResponse {
-    CompositionErrors(Vec<check_partial_schema_query::CheckPartialSchemaQueryServiceCheckPartialSchemaCompositionValidationResultErrors>),
-    CheckResult(CheckResult)
-}
-
-#[derive(Debug)]
-pub struct CheckResult {
-    pub target_url: Option<Url>,
-    pub number_of_checked_operations: i64,
-    pub change_severity: check_partial_schema_query::ChangeSeverity,
-    pub changes: Vec<check_partial_schema_query::CheckPartialSchemaQueryServiceCheckPartialSchemaCheckSchemaResultDiffToPreviousChanges>,
-}
-
 fn get_check_response_from_data(
-    data: check_partial_schema_query::ResponseData,
-    graph: String,
-) -> Result<CheckResponse, RoverClientError> {
-    let service = data.service.ok_or(RoverClientError::NoService { graph })?;
+    data: subgraph_check_query::ResponseData,
+    graph_name: String,
+) -> Result<SubgraphCheckResponse, RoverClientError> {
+    let service = data.service.ok_or(RoverClientError::NoService {
+        graph: graph_name.clone(),
+    })?;
 
     // for some reason this is a `Vec<Option<CompositionError>>`
     // we convert this to just `Vec<CompositionError>` because the `None`
     // errors would be useless.
-    let composition_errors: Vec<check_partial_schema_query::CheckPartialSchemaQueryServiceCheckPartialSchemaCompositionValidationResultErrors> = service
+    let query_composition_errors: Vec<subgraph_check_query::SubgraphCheckQueryServiceCheckPartialSchemaCompositionValidationResultErrors> = service
         .check_partial_schema
         .composition_validation_result
         .errors;
 
-    if composition_errors.is_empty() {
+    if query_composition_errors.is_empty() {
         let check_schema_result = service.check_partial_schema.check_schema_result.ok_or(
             RoverClientError::MalformedResponse {
                 null_field: "service.check_partial_schema.check_schema_result".to_string(),
             },
         )?;
 
-        let target_url = get_url(check_schema_result.target_url);
-
         let diff_to_previous = check_schema_result.diff_to_previous;
 
         let number_of_checked_operations =
             diff_to_previous.number_of_checked_operations.unwrap_or(0);
 
-        let change_severity = diff_to_previous.severity;
-        let changes = diff_to_previous.changes;
+        let change_severity = diff_to_previous.severity.into();
 
-        let check_result = CheckResult {
-            target_url,
+        let mut changes = Vec::with_capacity(diff_to_previous.changes.len());
+        for change in diff_to_previous.changes {
+            changes.push(SchemaChange {
+                code: change.code,
+                severity: change.severity.into(),
+                description: change.description,
+            });
+        }
+
+        let check_result = SubgraphCheckResponse {
+            target_url: check_schema_result.target_url,
             number_of_checked_operations,
-            change_severity,
             changes,
+            change_severity,
         };
 
-        Ok(CheckResponse::CheckResult(check_result))
+        Ok(check_result)
     } else {
-        Ok(CheckResponse::CompositionErrors(composition_errors))
-    }
-}
-
-fn get_url(url: Option<String>) -> Option<Url> {
-    match url {
-        Some(url) => {
-            let url = Url::parse(&url);
-            match url {
-                Ok(url) => Some(url),
-                // if the API returns an invalid URL, don't put it in the response
-                Err(_) => None,
-            }
+        let num_failures = query_composition_errors.len();
+
+        let mut composition_errors = Vec::with_capacity(num_failures);
+        for query_composition_error in query_composition_errors {
+            composition_errors.push(CompositionError {
+                message: query_composition_error.message,
+                code: query_composition_error.code,
+            });
         }
-        None => None,
+        Err(RoverClientError::SubgraphCompositionErrors {
+            graph_name,
+            composition_errors,
+        })
     }
 }

crates/rover-client/src/query/subgraph/check.rs crates/rover-client/src/query/subgraph/check/query_runner.rs

@@ -0,0 +1,101 @@
+use std::fmt;
+
+use crate::utils::GitContext;
+
+use super::query_runner::subgraph_check_query;
+
+pub(crate) type Timestamp = String;
+type QueryVariables = subgraph_check_query::Variables;
+type QueryChangeSeverity = subgraph_check_query::ChangeSeverity;
+type QuerySchema = subgraph_check_query::PartialSchemaInput;
+type QueryConfig = subgraph_check_query::HistoricQueryParameters;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct SubgraphCheckInput {
+    pub graph_id: String,
+    pub variant: String,
+    pub subgraph: String,
+    pub proposed_schema: String,
+    pub git_context: GitContext,
+    pub config: SubgraphCheckConfig,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct SubgraphCheckConfig {
+    pub query_count_threshold: Option<i64>,
+    pub query_count_threshold_percentage: Option<f64>,
+    pub validation_period_from: Option<String>,
+    pub validation_period_to: Option<String>,
+}
+
+impl From<SubgraphCheckInput> for QueryVariables {
+    fn from(input: SubgraphCheckInput) -> Self {
+        Self {
+            graph_id: input.graph_id,
+            variant: input.variant,
+            subgraph: input.subgraph,
+            proposed_schema: QuerySchema {
+                sdl: Some(input.proposed_schema),
+                hash: None,
+            },
+            config: QueryConfig {
+                query_count_threshold: input.config.query_count_threshold,
+                query_count_threshold_percentage: input.config.query_count_threshold_percentage,
+                from: input.config.validation_period_from,
+                to: input.config.validation_period_to,
+                // we don't support configuring these, but we can't leave them out
+                excluded_clients: None,
+                ignored_operations: None,
+                included_variants: None,
+            },
+            git_context: input.git_context.into(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct SubgraphCheckResponse {
+    pub target_url: Option<String>,
+    pub number_of_checked_operations: i64,
+    pub changes: Vec<SchemaChange>,
+    pub change_severity: ChangeSeverity,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ChangeSeverity {
+    PASS,
+    FAIL,
+}
+
+impl fmt::Display for ChangeSeverity {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let msg = match self {
+            ChangeSeverity::PASS => "PASS",
+            ChangeSeverity::FAIL => "FAIL",
+        };
+        write!(f, "{}", msg)
+    }
+}
+
+impl From<QueryChangeSeverity> for ChangeSeverity {
+    fn from(severity: QueryChangeSeverity) -> Self {
+        match severity {
+            QueryChangeSeverity::NOTICE => ChangeSeverity::PASS,
+            QueryChangeSeverity::FAILURE => ChangeSeverity::FAIL,
+            _ => unreachable!("Unknown change severity"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct SchemaChange {
+    pub code: String,
+    pub description: String,
+    pub severity: ChangeSeverity,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct CompositionError {
+    pub message: String,
+    pub code: Option<String>,
+}