feat(rover-error): scaffolds error codes and suggestions

Author: EverlastingBugstopper

Cargo.lock

@@ -5,4 +5,7 @@ authors = ["Apollo Developers <[email protected]>"]
 edition = "2018"
 
 [dependencies]
+ansi_term = "0.12"
 anyhow = "1.0"
+houston = { path = "../houston" }
+rover-client = { path = "../rover-client" }

crates/rover-error/Cargo.toml

@@ -1,30 +1,53 @@
+use std::borrow::BorrowMut;
 use std::fmt::{self, Debug, Display};
 
 pub type Result<T> = std::result::Result<T, RoverError>;
 
+use crate::Metadata;
+
+use ansi_term::Colour::{Cyan, Red};
+
 /// A specialized `Error` type for Rover.
 /// For now it's just a wrapper around `anyhow`, but
 /// eventually we'd like to add status codes and custom
 //  Display implementations
 #[derive(Debug)]
 pub struct RoverError {
     error: anyhow::Error,
+    metadata: Metadata,
 }
 
 impl RoverError {
     pub fn new<E>(error: E) -> Self
     where
         E: Into<anyhow::Error>,
     {
-        Self {
-            error: error.into(),
-        }
+        let mut error = error.into();
+        let metadata = Metadata::from(error.borrow_mut());
+
+        Self { error, metadata }
     }
 }
 
 impl Display for RoverError {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Display::fmt(&self.error, formatter)
+        let error_descriptor_message = if let Some(code) = &self.metadata.code {
+            format!("error[{}]:", code)
+        } else {
+            "error:".to_string()
+        };
+        let error_descriptor = Red.bold().paint(&error_descriptor_message);
+        writeln!(formatter, "{} {}", error_descriptor, &self.error)?;
+
+        if let Some(solution) = &self.metadata.solution {
+            let mut solution_descriptor_message = "".to_string();
+            for _ in 0..error_descriptor_message.len() + 1 {
+                solution_descriptor_message.push(' ');
+            }
+            let solution_descriptor = Cyan.bold().paint(&solution_descriptor_message);
+            write!(formatter, "{} {}", solution_descriptor, solution)?;
+        }
+        Ok(())
     }
 }
 

crates/rover-error/src/error.rs

@@ -1,3 +1,6 @@
 mod error;
+mod metadata;
+
 pub use anyhow::{anyhow, Context};
 pub use error::{Result, RoverError};
+pub(crate) use metadata::Metadata;

crates/rover-error/src/lib.rs

@@ -0,0 +1,10 @@
+use std::fmt::{self, Display};
+
+#[derive(Debug)]
+pub enum Code {}
+
+impl Display for Code {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(formatter, "{:?}", &self)
+    }
+}

crates/rover-error/src/metadata/code.rs

@@ -0,0 +1,43 @@
+mod code;
+mod suggestion;
+
+use code::Code;
+use suggestion::Suggestion;
+
+use houston::HoustonProblem;
+use rover_client::RoverClientError;
+
+#[derive(Default, Debug)]
+pub struct Metadata {
+    pub solution: Option<Suggestion>,
+    pub code: Option<Code>,
+}
+
+impl From<&mut anyhow::Error> for Metadata {
+    fn from(error: &mut anyhow::Error) -> Self {
+        if let Some(rover_client_error) = error.downcast_ref::<RoverClientError>() {
+            let (solution, code) = match rover_client_error {
+                RoverClientError::InvalidJSON(_)
+                | RoverClientError::InvalidHeaderName(_)
+                | RoverClientError::InvalidHeaderValue(_)
+                | RoverClientError::SendRequest(_)
+                | RoverClientError::NoCheckData
+                | RoverClientError::InvalidSeverity => (Some(Suggestion::SubmitIssue), None),
+                _ => (None, None),
+            };
+            return Metadata { solution, code };
+        }
+
+        if let Some(houston_problem) = error.downcast_ref::<HoustonProblem>() {
+            let (solution, code) = match houston_problem {
+                HoustonProblem::NoNonSensitiveConfigFound(_) => {
+                    (Some(Suggestion::RerunWithSensitive), None)
+                }
+                _ => (None, None),
+            };
+            return Metadata { solution, code };
+        }
+
+        Metadata::default()
+    }
+}

crates/rover-error/src/metadata/mod.rs

@@ -0,0 +1,26 @@
+use std::fmt::{self, Display};
+
+use ansi_term::Colour::{Cyan, Yellow};
+
+#[derive(Debug)]
+pub enum Suggestion {
+    SubmitIssue,
+    RerunWithSensitive,
+}
+
+impl Display for Suggestion {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let suggestion = match self {
+            Suggestion::SubmitIssue => {
+                format!("This error was unexpected! Please submit an issue with any relevant details about what you were trying to do: {}", Cyan.normal().paint("https://github.com/apollographql/rover/issues/new"))
+            }
+            Suggestion::RerunWithSensitive => {
+                format!(
+                    "Try re-running this command with the {} flag",
+                    Yellow.normal().paint("'--sensitive'")
+                )
+            }
+        };
+        write!(formatter, "{}", &suggestion)
+    }
+}

crates/rover-error/src/metadata/suggestion.rs

@@ -1,20 +1,30 @@
+use command::RoverStdout;
 use robot_panic::setup_panic;
 use rover::*;
 use rover_error::Result;
 use sputnik::Session;
 use structopt::StructOpt;
 
-use std::thread;
+use std::{process, thread};
 
-fn main() -> Result<()> {
+fn main() {
     setup_panic!();
+    if let Err(error) = run() {
+        tracing::debug!(?error);
+        eprintln!("{}", error);
+        process::exit(1)
+    } else {
+        process::exit(0)
+    }
+}
 
+fn run() -> Result<()> {
     let app = cli::Rover::from_args();
     timber::init(app.log_level);
     tracing::trace!(command_structure = ?app);
 
     // attempt to create a new `Session` to capture anonymous usage data
-    let result = match Session::new(&app) {
+    let output: RoverStdout = match Session::new(&app) {
         // if successful, report the usage data in the background
         Ok(session) => {
             // kicks off the reporting on a background thread
@@ -45,6 +55,6 @@ fn main() -> Result<()> {
         Err(_) => app.run(),
     }?;
 
-    result.print();
+    output.print();
     Ok(())
 }

src/bin/rover.rs

@@ -2,7 +2,7 @@ use serde::Serialize;
 use structopt::StructOpt;
 
 use houston as config;
-use rover_error::{anyhow, Result};
+use rover_error::Result;
 
 use crate::command::RoverStdout;
 #[derive(Debug, Serialize, StructOpt)]
@@ -24,15 +24,7 @@ impl Show {
             sensitive: self.sensitive,
         };
 
-        let profile = config::Profile::load(&self.name, &config, opts).map_err(|e| {
-            let context = match e {
-            config::HoustonProblem::NoNonSensitiveConfigFound(_) => {
-                "Could not show any profile information. Try re-running with the `--sensitive` flag"
-            }
-            _ => "Could not load profile",
-        };
-            anyhow!(e).context(context)
-        })?;
+        let profile = config::Profile::load(&self.name, &config, opts)?;
 
         tracing::info!("{}: {}", &self.name, profile);
         Ok(RoverStdout::None)

src/command/config/profile/show.rs

@@ -2,7 +2,7 @@ use serde::Serialize;
 use structopt::StructOpt;
 
 use rover_client::query::graph::fetch;
-use rover_error::{Context, Result};
+use rover_error::Result;
 
 use crate::client::StudioClientConfig;
 use crate::command::RoverStdout;
@@ -39,8 +39,7 @@ impl Fetch {
                 variant: Some(self.graph.variant.clone()),
             },
             &client,
-        )
-        .context("Failed while fetching from Apollo Studio")?;
+        )?;
 
         Ok(RoverStdout::SDL(sdl))
     }