Add custom error reporting type to CLI

Example error:

erewhon.tom.~/src/graphql-client/graphql_client_cli λ cargo run generate oi --schema-path=ui
    Blocking waiting for file lock on build directory
   Compiling graphql_client_cli v0.9.0 (/home/tom/src/graphql-client/graphql_client_cli)
    Finished dev [unoptimized + debuginfo] target(s) in 4.78s
     Running `/home/tom/src/graphql-client/target/debug/graphql-client generate oi --schema-path=ui`
Error: Error generating module code: Could not find file with path: ui

                Hint: file paths in the GraphQLQuery attribute are relative to the project root (location of the Cargo.toml). Example: query_path = "src/my_query.graphql".

Location: graphql_client_cli/src/generate.rs:75:24

Author: tomhoule

graphql_client/src/lib.rs

@@ -9,7 +9,7 @@
 //!
 //! - `graphql_query_derive` (default: on): enables the `#[derive(GraphqlQuery)]` custom derive.
 //! - `reqwest` (default: off): exposes the `graphql_client::reqwest::post_graphql()` function.
-//! - `reqwest_blocking` (default: off): exposes the blocking version, `graphql_client::reqwest::post_graphql_blocking()`.
+//! - `reqwest-blocking` (default: off): exposes the blocking version, `graphql_client::reqwest::post_graphql_blocking()`.
 
 #![deny(missing_docs)]
 #![warn(rust_2018_idioms)]
@@ -26,7 +26,7 @@ pub use graphql_query_derive::*;
 #[cfg(any(feature = "reqwest", feature = "reqwest-blocking"))]
 pub mod reqwest;
 
-use serde::*;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fmt::{self, Display};
 

graphql_client_cli/Cargo.toml

@@ -13,7 +13,7 @@ path = "src/main.rs"
 
 [dependencies]
 reqwest = { version = "^0.11", features = ["json", "blocking"] }
-graphql_client = { version = "0.9.0", path = "../graphql_client", default-features = false, features = ["graphql_query_derive"] }
+graphql_client = { version = "0.9.0", path = "../graphql_client", default-features = false, features = ["graphql_query_derive", "reqwest-blocking"] }
 graphql_client_codegen = { path = "../graphql_client_codegen/", version = "0.9.0" }
 structopt = "0.3"
 serde = { version = "^1.0", features = ["derive"] }

graphql_client_cli/src/error.rs

@@ -0,0 +1,65 @@
+use std::fmt::{Debug, Display};
+
+pub struct Error {
+    source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
+    message: Option<String>,
+    location: &'static std::panic::Location<'static>,
+}
+
+impl Error {
+    #[track_caller]
+    pub fn message(msg: String) -> Self {
+        Error {
+            source: None,
+            message: Some(msg),
+            location: std::panic::Location::caller(),
+        }
+    }
+
+    #[track_caller]
+    pub fn source_with_message(
+        source: impl std::error::Error + Send + Sync + 'static,
+        message: String,
+    ) -> Self {
+        let mut err = Error::message(message);
+        err.source = Some(Box::new(source));
+        err
+    }
+}
+
+// This is the impl that shows up when the error bubbles up to `main()`.
+impl Debug for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(msg) = &self.message {
+            f.write_str(msg)?;
+            f.write_str("\n")?;
+        }
+
+        if self.source.is_some() && self.message.is_some() {
+            f.write_str("Cause: ")?;
+        }
+
+        if let Some(source) = self.source.as_ref() {
+            Display::fmt(source, f)?;
+        }
+
+        f.write_str("\nLocation: ")?;
+        Display::fmt(self.location, f)?;
+
+        Ok(())
+    }
+}
+
+impl<T> From<T> for Error
+where
+    T: std::error::Error + Send + Sync + 'static,
+{
+    #[track_caller]
+    fn from(err: T) -> Self {
+        Error {
+            message: None,
+            source: Some(Box::new(err)),
+            location: std::panic::Location::caller(),
+        }
+    }
+}

graphql_client_cli/src/generate.rs

@@ -1,6 +1,9 @@
+use crate::error::Error;
+use crate::CliResult;
 use graphql_client_codegen::{
     generate_module_token_stream, CodegenMode, GraphQLClientCodegenOptions,
 };
+use std::ffi::OsString;
 use std::fs::File;
 use std::io::Write as _;
 use std::path::PathBuf;
@@ -20,7 +23,7 @@ pub(crate) struct CliCodegenParams {
     pub custom_scalars_module: Option<String>,
 }
 
-pub(crate) fn generate_code(params: CliCodegenParams) {
+pub(crate) fn generate_code(params: CliCodegenParams) -> CliResult<()> {
     let CliCodegenParams {
         variables_derives,
         response_derives,
@@ -62,49 +65,59 @@ pub(crate) fn generate_code(params: CliCodegenParams) {
     }
 
     if let Some(custom_scalars_module) = custom_scalars_module {
-        let custom_scalars_module =
-            syn::parse_str(&custom_scalars_module).expect("Invalid custom scalar module path");
+        let custom_scalars_module = syn::parse_str(&custom_scalars_module)
+            .map_err(|_| Error::message("Invalid custom scalar module path".to_owned()))?;
 
         options.set_custom_scalars_module(custom_scalars_module);
     }
 
-    let gen = generate_module_token_stream(query_path.clone(), &schema_path, options).unwrap();
+    let gen = generate_module_token_stream(query_path.clone(), &schema_path, options)
+        .map_err(|err| Error::message(format!("Error generating module code: {}", err)))?;
 
     let generated_code = gen.to_string();
     let generated_code = if !no_formatting {
-        format(&generated_code)
+        format(&generated_code)?
     } else {
         generated_code
     };
 
-    let query_file_name: ::std::ffi::OsString = query_path
-        .file_name()
-        .map(ToOwned::to_owned)
-        .ok_or_else(|| "Failed to find a file name in the provided query path.".to_owned())
-        .unwrap();
+    let query_file_name: OsString =
+        query_path
+            .file_name()
+            .map(ToOwned::to_owned)
+            .ok_or_else(|| {
+                Error::message("Failed to find a file name in the provided query path.".to_owned())
+            })?;
 
     let dest_file_path: PathBuf = output_directory
         .map(|output_dir| output_dir.join(query_file_name).with_extension("rs"))
         .unwrap_or_else(move || query_path.with_extension("rs"));
 
     log::info!("Writing generated query to {:?}", dest_file_path);
 
-    let mut file = File::create(dest_file_path).unwrap();
-    write!(file, "{}", generated_code).unwrap();
+    let mut file = File::create(&dest_file_path).map_err(|err| {
+        Error::source_with_message(
+            err,
+            format!("Creating file at {}", dest_file_path.display()),
+        )
+    })?;
+    write!(file, "{}", generated_code)?;
+
+    Ok(())
 }
 
-fn format(code: &str) -> String {
+fn format(code: &str) -> CliResult<String> {
     let binary = "rustfmt";
 
     let mut child = std::process::Command::new(binary)
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .spawn()
-        .unwrap();
+        .map_err(|err| Error::source_with_message(err, "Error spawning rustfmt".to_owned()))?;
     let child_stdin = child.stdin.as_mut().unwrap();
-    write!(child_stdin, "{}", code).unwrap();
+    write!(child_stdin, "{}", code)?;
 
-    let output = child.wait_with_output().unwrap();
+    let output = child.wait_with_output()?;
 
     if !output.status.success() {
         panic!(
@@ -113,5 +126,5 @@ fn format(code: &str) -> String {
         );
     }
 
-    String::from_utf8(output.stdout).unwrap()
+    Ok(String::from_utf8(output.stdout)?)
 }

graphql_client_cli/src/introspect_schema.rs

@@ -1,3 +1,4 @@
+use crate::CliResult;
 use graphql_client::GraphQLQuery;
 use reqwest::header::{HeaderMap, HeaderValue, ACCEPT, CONTENT_TYPE};
 use std::path::PathBuf;
@@ -19,11 +20,11 @@ pub fn introspect_schema(
     authorization: Option<String>,
     headers: Vec<Header>,
     no_ssl: bool,
-) {
+) -> CliResult<()> {
     use std::io::Write;
 
     let out: Box<dyn Write> = match output {
-        Some(path) => Box::new(::std::fs::File::create(path).unwrap()),
+        Some(path) => Box::new(::std::fs::File::create(path)?),
         None => Box::new(std::io::stdout()),
     };
 
@@ -35,8 +36,7 @@ pub fn introspect_schema(
 
     let client = reqwest::blocking::Client::builder()
         .danger_accept_invalid_certs(no_ssl)
-        .build()
-        .unwrap();
+        .build()?;
 
     let mut req_builder = client.post(location).headers(construct_headers());
 
@@ -48,7 +48,7 @@ pub fn introspect_schema(
         req_builder = req_builder.bearer_auth(token.as_str());
     };
 
-    let res = req_builder.json(&request_body).send().unwrap();
+    let res = req_builder.json(&request_body).send()?;
 
     if res.status().is_success() {
         // do nothing
@@ -58,8 +58,10 @@ pub fn introspect_schema(
         println!("Something else happened. Status: {:?}", res.status());
     }
 
-    let json: serde_json::Value = res.json().unwrap();
-    serde_json::to_writer_pretty(out, &json).unwrap();
+    let json: serde_json::Value = res.json()?;
+    serde_json::to_writer_pretty(out, &json)?;
+
+    Ok(())
 }
 
 fn construct_headers() -> HeaderMap {

graphql_client_cli/src/main.rs

@@ -1,13 +1,17 @@
 #![allow(clippy::redundant_clone)] // in structopt generated code
 
-use env_logger::fmt::{Color, Style, StyledValue};
-use log::Level;
-
+mod error;
 mod generate;
 mod introspect_schema;
+
+use env_logger::fmt::{Color, Style, StyledValue};
+use error::Error;
+use log::Level;
 use std::path::PathBuf;
 use structopt::StructOpt;
 
+type CliResult<T> = Result<T, Error>;
+
 #[derive(StructOpt)]
 #[structopt(author, about)]
 enum Cli {
@@ -75,7 +79,7 @@ enum Cli {
     },
 }
 
-fn main() {
+fn main() -> CliResult<()> {
     set_env_logger();
 
     let cli = Cli::from_args();