Merge pull request #324 from graphql-rust/drop-anyhow

Drop anyhow

Author: tomhoule

graphql_client_cli/src/generate.rs

@@ -59,7 +59,7 @@ pub(crate) fn generate_code(params: CliCodegenParams) -> Result<()> {
         options.set_deprecation_strategy(deprecation_strategy);
     }
 
-    let gen = generate_module_token_stream(query_path.clone(), &schema_path, options)?;
+    let gen = generate_module_token_stream(query_path.clone(), &schema_path, options).unwrap();
 
     let generated_code = gen.to_string();
     let generated_code = if cfg!(feature = "rustfmt") && !no_formatting {

graphql_client_cli/src/introspect_schema.rs

@@ -1,4 +1,4 @@
-use anyhow::format_err;
+use anyhow::*;
 use graphql_client::GraphQLQuery;
 use reqwest::header::{HeaderMap, HeaderValue, ACCEPT, CONTENT_TYPE};
 use std::path::PathBuf;

graphql_client_codegen/Cargo.toml

@@ -8,7 +8,6 @@ repository = "https://github.com/graphql-rust/graphql-client"
 edition = "2018"
 
 [dependencies]
-anyhow = "1.0"
 graphql-introspection-query = { version = "0.1.0", path = "../graphql-introspection-query" }
 graphql-parser = "^0.2"
 heck = "0.3"

graphql_client_codegen/src/codegen.rs

@@ -7,7 +7,7 @@ use crate::{
     query::*,
     schema::{InputId, TypeId},
     type_qualifiers::GraphqlTypeQualifier,
-    GraphQLClientCodegenOptions,
+    GeneralError, GraphQLClientCodegenOptions,
 };
 use heck::SnakeCase;
 use proc_macro2::{Ident, Span, TokenStream};
@@ -20,7 +20,7 @@ pub(crate) fn response_for_query(
     operation_id: OperationId,
     options: &GraphQLClientCodegenOptions,
     query: BoundQuery<'_>,
-) -> anyhow::Result<TokenStream> {
+) -> Result<TokenStream, GeneralError> {
     let all_used_types = all_used_types(operation_id, &query);
     let response_derives = render_derives(options.all_response_derives());
     let variable_derives = render_derives(options.all_variable_derives());

graphql_client_codegen/src/generated_module.rs

@@ -1,10 +1,21 @@
 use crate::{
     codegen_options::*,
     query::{BoundQuery, OperationId},
+    BoxError,
 };
 use heck::*;
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+#[error(
+    "Could not find an operation named {} in the query document.",
+    operation_name
+)]
+struct OperationNotFound {
+    operation_name: String,
+}
 
 /// This struct contains the parameters necessary to generate code for a given operation.
 pub(crate) struct GeneratedModule<'a> {
@@ -17,7 +28,7 @@ pub(crate) struct GeneratedModule<'a> {
 
 impl<'a> GeneratedModule<'a> {
     /// Generate the items for the variables and the response that will go inside the module.
-    fn build_impls(&self) -> anyhow::Result<TokenStream> {
+    fn build_impls(&self) -> Result<TokenStream, BoxError> {
         Ok(crate::codegen::response_for_query(
             self.root()?,
             &self.options,
@@ -28,21 +39,18 @@ impl<'a> GeneratedModule<'a> {
         )?)
     }
 
-    fn root(&self) -> anyhow::Result<OperationId> {
+    fn root(&self) -> Result<OperationId, OperationNotFound> {
         let op_name = self.options.normalization().operation(self.operation);
         self.resolved_query
             .select_operation(&op_name, *self.options.normalization())
             .map(|op| op.0)
-            .ok_or_else(|| {
-                anyhow::anyhow!(
-                    "Could not find an operation named {} in the query document.",
-                    op_name
-                )
+            .ok_or_else(|| OperationNotFound {
+                operation_name: op_name.into(),
             })
     }
 
     /// Generate the module and all the code inside.
-    pub(crate) fn to_token_stream(&self) -> anyhow::Result<TokenStream> {
+    pub(crate) fn to_token_stream(&self) -> Result<TokenStream, BoxError> {
         let module_name = Ident::new(&self.operation.to_snake_case(), Span::call_site());
         let module_visibility = &self.options.module_visibility();
         let operation_name = self.operation;
@@ -76,6 +84,8 @@ impl<'a> GeneratedModule<'a> {
             #module_visibility mod #module_name {
                 #![allow(dead_code)]
 
+                use std::result::Result;
+
                 pub const OPERATION_NAME: &'static str = #operation_name;
                 pub const QUERY: &'static str = #query_string;
 

graphql_client_codegen/src/lib.rs

@@ -6,7 +6,6 @@
 //!
 //! It is not meant to be used directly by users of the library.
 
-use anyhow::format_err;
 use lazy_static::*;
 use proc_macro2::TokenStream;
 use quote::*;
@@ -30,8 +29,14 @@ mod tests;
 
 pub use crate::codegen_options::{CodegenMode, GraphQLClientCodegenOptions};
 
-use std::collections::HashMap;
+use std::{collections::HashMap, io};
+use thiserror::Error;
 
+#[derive(Debug, Error)]
+#[error("{0}")]
+struct GeneralError(String);
+
+type BoxError = Box<dyn std::error::Error + Send + Sync + 'static>;
 type CacheMap<T> = std::sync::Mutex<HashMap<std::path::PathBuf, T>>;
 
 lazy_static! {
@@ -45,7 +50,7 @@ pub fn generate_module_token_stream(
     query_path: std::path::PathBuf,
     schema_path: &std::path::Path,
     options: GraphQLClientCodegenOptions,
-) -> anyhow::Result<TokenStream> {
+) -> Result<TokenStream, BoxError> {
     use std::collections::hash_map;
 
     let schema_extension = schema_path
@@ -62,14 +67,14 @@ pub fn generate_module_token_stream(
                 let schema_string = read_file(v.key())?;
                 let schema = match schema_extension {
                     "graphql" | "gql" => {
-                        let s = graphql_parser::schema::parse_schema(&schema_string).map_err(|parser_error| anyhow::anyhow!("Parser error: {}", parser_error))?;
+                        let s = graphql_parser::schema::parse_schema(&schema_string).map_err(|parser_error| GeneralError(format!("Parser error: {}", parser_error)))?;
                         schema::Schema::from(s)
                     }
                     "json" => {
                         let parsed: graphql_introspection_query::introspection_response::IntrospectionResponse = serde_json::from_str(&schema_string)?;
                         schema::Schema::from(parsed)
                     }
-                    extension => panic!("Unsupported extension for the GraphQL schema: {} (only .json and .graphql are supported)", extension)
+                    extension => return Err(GeneralError(format!("Unsupported extension for the GraphQL schema: {} (only .json and .graphql are supported)", extension)).into())
                 };
 
                 v.insert(schema).clone()
@@ -85,7 +90,7 @@ pub fn generate_module_token_stream(
             hash_map::Entry::Vacant(v) => {
                 let query_string = read_file(v.key())?;
                 let query = graphql_parser::parse_query(&query_string)
-                    .map_err(|err| anyhow::anyhow!("Query parser error: {}", err))?;
+                    .map_err(|err| GeneralError(format!("Query parser error: {}", err)))?;
                 v.insert((query_string, query)).clone()
             }
         }
@@ -104,10 +109,11 @@ pub fn generate_module_token_stream(
         (Some(ops), _) => ops,
         (None, &CodegenMode::Cli) => query.operations().collect(),
         (None, &CodegenMode::Derive) => {
-            return Err(derive_operation_not_found_error(
+            return Err(GeneralError(derive_operation_not_found_error(
                 options.struct_ident(),
                 &query,
-            ));
+            ))
+            .into());
         }
     };
 
@@ -131,30 +137,49 @@ pub fn generate_module_token_stream(
     Ok(modules)
 }
 
-fn read_file(path: &std::path::Path) -> anyhow::Result<String> {
+#[derive(Debug, Error)]
+enum ReadFileError {
+    #[error(
+        "Could not find file with path: {}\
+        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\".",
+        path
+    )]
+    FileNotFound {
+        path: String,
+        #[source]
+        io_error: io::Error,
+    },
+    #[error("Error reading file at: {}", path)]
+    ReadError {
+        path: String,
+        #[source]
+        io_error: io::Error,
+    },
+}
+
+fn read_file(path: &std::path::Path) -> Result<String, ReadFileError> {
     use std::fs;
     use std::io::prelude::*;
 
     let mut out = String::new();
-    let mut file = fs::File::open(path).map_err(|io_err| {
-        let err: anyhow::Error = io_err.into();
-        err.context(format!(
-            r#"
-            Could not find file with path: {}
-            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".
-            "#,
-            path.display()
-        ))
+    let mut file = fs::File::open(path).map_err(|io_error| ReadFileError::FileNotFound {
+        io_error,
+        path: path.display().to_string(),
     })?;
-    file.read_to_string(&mut out)?;
+
+    file.read_to_string(&mut out)
+        .map_err(|io_error| ReadFileError::ReadError {
+            io_error,
+            path: path.display().to_string(),
+        })?;
     Ok(out)
 }
 
 /// In derive mode, build an error when the operation with the same name as the struct is not found.
 fn derive_operation_not_found_error(
     ident: Option<&proc_macro2::Ident>,
     query: &crate::query::Query,
-) -> anyhow::Error {
+) -> String {
     let operation_name = ident.map(ToString::to_string);
     let struct_ident = operation_name.as_deref().unwrap_or("");
 
@@ -164,7 +189,7 @@ fn derive_operation_not_found_error(
         .collect();
     let available_operations: String = available_operations.join(", ");
 
-    return format_err!(
+    return format!(
         "The struct name does not match any defined operation in the query file.\nStruct name: {}\nDefined operations: {}",
         struct_ident,
         available_operations,