feat(rover): graph checks

Author: EverlastingBugstopper

Cargo.lock

@@ -19,12 +19,13 @@ binstall = { path = "./installers/binstall" }
 anyhow = "1.0.31"
 atty = "0.2.14"
 console = "0.13.0"
+prettytable-rs = "0.8.0"
 serde = "1.0"
 serde_json = "1.0"
 structopt = "0.3.15"
-url = "2.1.1"
 tracing = "0.1.21"
 regex = "1"
+url = "2.1.1"
 
 [dev-dependencies]
 assert_cmd = "1.0.1"

Cargo.toml

@@ -13,6 +13,7 @@ reqwest = { version = "0.10", features = ["json", "blocking", "native-tls-vendor
 serde = "1"
 serde_json = "1"
 thiserror = "1"
+tracing = "0.1"
 
 [build-dependencies]
 online = "0.2.2"

crates/rover-client/Cargo.toml

@@ -15,6 +15,10 @@ pub enum RoverClientError {
     #[error("invalid header value")]
     InvalidHeaderValue(#[from] reqwest::header::InvalidHeaderValue),
 
+    /// Invalid JSON in response body.
+    #[error("could not parse JSON")]
+    InvalidJSON(#[from] serde_json::Error),
+
     /// Encountered an error handling the received response.
     #[error("encountered an error handling the response: {msg}")]
     HandleResponse {
@@ -32,9 +36,13 @@ pub enum RoverClientError {
     #[error("The response from the server was malformed. There was no data found in the reponse body. This is likely an error in GraphQL execution")]
     NoData,
 
-    /// when someone provides a bad service/variant combingation or isn't
+    /// when someone provides a bad service/variant combination or isn't
     /// validated properly, we don't know which reason is at fault for data.service
     /// being empty, so this error tells them to check both.
     #[error("No service found. Either the service/variant combination wasn't found or your API key is invalid.")]
     NoService,
+
+    /// The API returned an invalid ChangeSeverity value
+    #[error("Invalid ChangeSeverity.")]
+    InvalidSeverity,
 }

crates/rover-client/src/error.rs

@@ -0,0 +1,23 @@
+mutation CheckSchemaQuery(
+    $graphId: ID!
+    $variant: String
+    $schema: String
+  ) {
+    service(id: $graphId) {
+      checkSchema(
+        proposedSchemaDocument: $schema
+        baseSchemaTag: $variant
+      ) {
+        targetUrl
+        diffToPrevious {
+          severity
+          numberOfCheckedOperations
+          changes {
+            severity
+            code
+            description
+          }
+        }
+      }
+    }
+  }

crates/rover-client/src/query/graph/check.graphql

@@ -0,0 +1,73 @@
+use crate::blocking::StudioClient;
+use crate::RoverClientError;
+use graphql_client::*;
+
+use reqwest::Url;
+
+#[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/graph/check.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_schema_query
+pub struct CheckSchemaQuery;
+
+/// The main function to be used from this module.
+/// This function takes a proposed schema and validates it against a pushed
+/// schema.
+pub fn run(
+    variables: check_schema_query::Variables,
+    client: &StudioClient,
+) -> Result<CheckResponse, RoverClientError> {
+    let data = client.post::<CheckSchemaQuery>(variables)?;
+    get_check_response_from_data(data)
+}
+
+#[derive(Debug)]
+pub struct CheckResponse {
+    pub target_url: Option<Url>,
+    pub number_of_checked_operations: i64,
+    pub change_severity: check_schema_query::ChangeSeverity,
+    pub changes: Vec<check_schema_query::CheckSchemaQueryServiceCheckSchemaDiffToPreviousChanges>,
+}
+
+fn get_check_response_from_data(
+    data: check_schema_query::ResponseData,
+) -> Result<CheckResponse, RoverClientError> {
+    let service = data.service.ok_or(RoverClientError::NoService)?;
+    let target_url = get_url(service.check_schema.target_url);
+
+    let diff_to_previous = service.check_schema.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;
+
+    Ok(CheckResponse {
+        target_url,
+        number_of_checked_operations,
+        change_severity,
+        changes,
+    })
+}
+
+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,
+            }
+        }
+        None => None,
+    }
+}

crates/rover-client/src/query/graph/check.rs

@@ -1,5 +1,8 @@
-/// "graph get" command execution
+/// "graph fetch" command execution
 pub mod fetch;
 
 /// "graph push" command execution
 pub mod push;
+
+/// "graph check" command exeuction
+pub mod check;

crates/rover-client/src/query/graph/mod.rs

@@ -0,0 +1,99 @@
+use std::path::PathBuf;
+
+use anyhow::{Context, Result};
+use prettytable::{cell, row, Table};
+use serde::Serialize;
+use structopt::StructOpt;
+
+use rover_client::query::graph::check;
+
+use crate::client::get_studio_client;
+use crate::command::RoverStdout;
+use crate::utils::parsers::{parse_graph_ref, GraphRef};
+
+#[derive(Debug, Serialize, StructOpt)]
+pub struct Check {
+    /// <NAME>@<VARIANT> of graph in Apollo Studio to validate.
+    /// @<VARIANT> may be left off, defaulting to @current
+    #[structopt(name = "GRAPH_REF", parse(try_from_str = parse_graph_ref))]
+    #[serde(skip_serializing)]
+    graph: GraphRef,
+
+    /// Name of configuration profile to use
+    #[structopt(long = "profile", default_value = "default")]
+    #[serde(skip_serializing)]
+    profile_name: String,
+
+    /// Path of .graphql/.gql schema file to push
+    #[structopt(long = "schema", short = "s")]
+    #[serde(skip_serializing)]
+    schema_path: PathBuf,
+}
+
+impl Check {
+    pub fn run(&self) -> Result<RoverStdout> {
+        let client =
+            get_studio_client(&self.profile_name).context("Failed to get studio client")?;
+        let schema = std::fs::read_to_string(&self.schema_path)
+            .with_context(|| format!("Could not read file `{}`", &self.schema_path.display()))?;
+        let res = check::run(
+            check::check_schema_query::Variables {
+                graph_id: self.graph.name.clone(),
+                variant: Some(self.graph.variant.clone()),
+                schema: Some(schema),
+            },
+            &client,
+        )
+        .context("Failed to validate schema")?;
+
+        tracing::info!(
+            "Validated schema against metrics from variant {} on graph {}",
+            &self.graph.variant,
+            &self.graph.name
+        );
+        tracing::info!(
+            "Compared {} schema changes against {} operations",
+            res.changes.len(),
+            res.number_of_checked_operations
+        );
+
+        if let Some(url) = res.target_url {
+            tracing::info!("View full details here");
+            tracing::info!("{}", url.to_string());
+        }
+
+        let num_failures = print_changes(&res.changes);
+
+        match num_failures {
+            0 => Ok(RoverStdout::None),
+            1 => Err(anyhow::anyhow!("Encountered 1 failure.")),
+            _ => Err(anyhow::anyhow!("Encountered {} failures.", num_failures)),
+        }
+    }
+}
+
+fn print_changes(
+    checks: &[check::check_schema_query::CheckSchemaQueryServiceCheckSchemaDiffToPreviousChanges],
+) -> u64 {
+    let mut num_failures = 0;
+
+    if !checks.is_empty() {
+        let mut table = Table::new();
+        table.add_row(row!["Change", "Code", "Description"]);
+        for check in checks {
+            let change = match check.severity {
+                check::check_schema_query::ChangeSeverity::NOTICE => "PASS",
+                check::check_schema_query::ChangeSeverity::FAILURE => {
+                    num_failures += 1;
+                    "FAIL"
+                }
+                _ => unreachable!("Unknown change severity"),
+            };
+            table.add_row(row![change, check.code, check.description]);
+        }
+
+        eprintln!("{}", table);
+    }
+
+    num_failures
+}

src/command/graph/check.rs

@@ -1,3 +1,4 @@
+mod check;
 mod fetch;
 mod push;
 
@@ -20,13 +21,17 @@ pub enum Command {
 
     /// Push a schema to Apollo Studio from a local file
     Push(push::Push),
+
+    /// ✔️  Validate changes to a graph
+    Check(check::Check),
 }
 
-impl<'a> Graph {
+impl Graph {
     pub fn run(&self) -> Result<RoverStdout> {
         match &self.command {
             Command::Fetch(command) => command.run(),
             Command::Push(command) => command.run(),
+            Command::Check(command) => command.run(),
         }
     }
 }