refactor(tauri): use explicit error types instead of anyhow (#1209)

Author: lucasfernog

.changes/core-errors.md

@@ -0,0 +1,5 @@
+---
+"tauri": minor
+---
+
+Tauri now uses explicit Error variants with `thiserror` instead of relying on `anyhow`.

tauri-api/Cargo.toml

@@ -24,7 +24,6 @@ semver = "0.11"
 tempfile = "3"
 either = "1.6.1"
 tar = "0.4"
-anyhow = "1.0.38"
 flate2 = "1.0"
 thiserror = "1.0.23"
 rand = "0.8"

tauri-api/src/cli.rs

@@ -58,7 +58,7 @@ pub fn get_matches(config: &Config) -> crate::Result<Matches> {
     .tauri
     .cli
     .as_ref()
-    .ok_or_else(|| anyhow::anyhow!("CLI configuration not defined"))?;
+    .ok_or_else(|| crate::Error::CliNotConfigured)?;
 
   let about = cli
     .description()

tauri-api/src/command.rs

@@ -16,7 +16,9 @@ pub fn get_output(cmd: String, args: Vec<String>, stdout: Stdio) -> crate::Resul
   if output.status.success() {
     Ok(String::from_utf8_lossy(&output.stdout).to_string())
   } else {
-    Err(crate::Error::Command(String::from_utf8_lossy(&output.stderr).to_string()).into())
+    Err(crate::Error::Command(
+      String::from_utf8_lossy(&output.stderr).to_string(),
+    ))
   }
 }
 
@@ -32,7 +34,9 @@ pub fn get_output(cmd: String, args: Vec<String>, stdout: Stdio) -> crate::Resul
   if output.status.success() {
     Ok(String::from_utf8_lossy(&output.stdout).to_string())
   } else {
-    Err(crate::Error::Command(String::from_utf8_lossy(&output.stderr).to_string()).into())
+    Err(crate::Error::Command(
+      String::from_utf8_lossy(&output.stderr).to_string(),
+    ))
   }
 }
 
@@ -41,7 +45,9 @@ pub fn get_output(cmd: String, args: Vec<String>, stdout: Stdio) -> crate::Resul
 pub fn command_path(command: String) -> crate::Result<String> {
   match std::env::current_exe()?.parent() {
     Some(exe_dir) => Ok(format!("{}/{}", exe_dir.display().to_string(), command)),
-    None => Err(crate::Error::Command("Could not evaluate executable dir".to_string()).into()),
+    None => Err(crate::Error::Command(
+      "Could not evaluate executable dir".to_string(),
+    )),
   }
 }
 
@@ -50,7 +56,9 @@ pub fn command_path(command: String) -> crate::Result<String> {
 pub fn command_path(command: String) -> crate::Result<String> {
   match std::env::current_exe()?.parent() {
     Some(exe_dir) => Ok(format!("{}/{}.exe", exe_dir.display().to_string(), command)),
-    None => Err(crate::Error::Command("Could not evaluate executable dir".to_string()).into()),
+    None => Err(crate::Error::Command(
+      "Could not evaluate executable dir".to_string(),
+    )),
   }
 }
 
@@ -86,14 +94,17 @@ pub fn spawn_relative_command(
 
 /// Gets the binary command with the current target triple.
 pub fn binary_command(binary_name: String) -> crate::Result<String> {
-  Ok(format!("{}-{}", binary_name, platform::target_triple()?))
+  Ok(format!(
+    "{}-{}",
+    binary_name,
+    platform::target_triple().map_err(|e| crate::Error::FailedToDetectPlatform(e.to_string()))?
+  ))
 }
 
 // tests for the commands functions.
 #[cfg(test)]
 mod test {
   use super::*;
-  use std::io;
 
   #[cfg(not(windows))]
   #[test]
@@ -131,7 +142,7 @@ mod test {
     assert!(res.is_err());
 
     // destruct the Error to check the ErrorKind and test that it is a Command type.
-    if let Some(Error::Command(e)) = res.unwrap_err().downcast_ref::<Error>() {
+    if let Error::Command(e) = res.unwrap_err() {
       // assert that the message in the error matches this string.
       assert_eq!(*e, "cat: test/: Is a directory\n".to_string());
     }
@@ -163,7 +174,7 @@ mod test {
     assert!(res.is_err());
 
     // after asserting that the result is an error, check that the error kind is ErrorKind::Io
-    if let Some(s) = res.unwrap_err().downcast_ref::<io::Error>() {
+    if let crate::Error::Io(s) = res.unwrap_err() {
       // assert that the ErrorKind inside of the ErrorKind Io is ErrorKind::NotFound
       assert_eq!(s.kind(), std::io::ErrorKind::NotFound);
     }

tauri-api/src/dialog.rs

@@ -16,9 +16,10 @@ fn open_dialog_internal(
       .map(|s| s.as_ref().to_string_lossy().to_string())
       .as_deref(),
     dialog_type,
-  )?;
+  )
+  .map_err(|e| crate::Error::Dialog(e.to_string()))?;
   match response {
-    Response::Cancel => Err(crate::Error::Dialog("user cancelled".into()).into()),
+    Response::Cancel => Err(crate::Error::DialogCancelled),
     _ => Ok(response),
   }
 }

tauri-api/src/error.rs

@@ -0,0 +1,58 @@
+/// The error types.
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+  /// The extract archive error.
+  #[error("Extract Error: {0}")]
+  Extract(String),
+  /// The Command (spawn process) error.
+  #[error("Command Error: {0}")]
+  Command(String),
+  /// The path operation error.
+  #[error("Path Error: {0}")]
+  Path(String),
+  /// Error showing the dialog.
+  #[error("Dialog Error: {0}")]
+  Dialog(String),
+  /// The dialog operation was cancelled by the user.
+  #[error("user cancelled the dialog")]
+  DialogCancelled,
+  /// CLI config not set.
+  #[error("CLI configuration not set on tauri.conf.json")]
+  CliNotConfigured,
+  /// The HTTP response error.
+  #[error("HTTP Response Error: {0}")]
+  Response(attohttpc::StatusCode),
+  /// The network error.
+  #[error("Network Error: {0}")]
+  Network(#[from] attohttpc::Error),
+  /// HTTP method error.
+  #[error("{0}")]
+  HttpMethod(#[from] http::method::InvalidMethod),
+  /// Invalid HTTO header.
+  #[error("{0}")]
+  HttpHeader(#[from] attohttpc::header::InvalidHeaderName),
+  /// Semver error.
+  #[error("{0}")]
+  Semver(#[from] semver::SemVerError),
+  /// JSON error.
+  #[error("{0}")]
+  Json(#[from] serde_json::Error),
+  /// IO error.
+  #[error("{0}")]
+  Io(#[from] std::io::Error),
+  /// ZIP error.
+  #[error("{0}")]
+  Zip(#[from] zip::result::ZipError),
+  /// Notification error.
+  #[error("{0}")]
+  Notification(#[from] notify_rust::error::Error),
+  /// failed to detect the current platform.
+  #[error("failed to detect platform: {0}")]
+  FailedToDetectPlatform(String),
+}
+
+impl From<attohttpc::StatusCode> for Error {
+  fn from(error: attohttpc::StatusCode) -> Self {
+    Self::Response(error)
+  }
+}

tauri-api/src/file.rs

@@ -4,19 +4,17 @@ mod file_move;
 use std::fs;
 use std::path::Path;
 
-use crate::Error;
-
 pub use extract::*;
 pub use file_move::*;
 
 /// Reads a string file.
 pub fn read_string<P: AsRef<Path>>(file: P) -> crate::Result<String> {
-  fs::read_to_string(file).map_err(|err| Error::File(format!("Read_string failed: {}", err)).into())
+  fs::read_to_string(file).map_err(|e| e.into())
 }
 
 /// Reads a binary file.
 pub fn read_binary<P: AsRef<Path>>(file: P) -> crate::Result<Vec<u8>> {
-  fs::read(file).map_err(|err| Error::File(format!("Read_binary failed: {}", err)).into())
+  fs::read(file).map_err(|e| e.into())
 }
 
 #[cfg(test)]
@@ -45,17 +43,11 @@ mod test {
 
     assert!(res.is_err());
 
-    if let Some(Error::File(e)) = res.unwrap_err().downcast_ref::<Error>() {
+    if let Error::Io(e) = res.unwrap_err() {
       #[cfg(windows)]
-      assert_eq!(
-        *e,
-        "Read_string failed: Access is denied. (os error 5)".to_string()
-      );
+      assert_eq!(e.to_string(), "Access is denied. (os error 5)".to_string());
       #[cfg(not(windows))]
-      assert_eq!(
-        *e,
-        "Read_string failed: Is a directory (os error 21)".to_string()
-      );
+      assert_eq!(e.to_string(), "Is a directory (os error 21)".to_string());
     }
   }
 
@@ -91,17 +83,11 @@ mod test {
 
     assert!(res.is_err());
 
-    if let Some(Error::File(e)) = res.unwrap_err().downcast_ref::<Error>() {
+    if let Error::Io(e) = res.unwrap_err() {
       #[cfg(windows)]
-      assert_eq!(
-        *e,
-        "Read_binary failed: Access is denied. (os error 5)".to_string()
-      );
+      assert_eq!(e.to_string(), "Access is denied. (os error 5)".to_string());
       #[cfg(not(windows))]
-      assert_eq!(
-        *e,
-        "Read_binary failed: Is a directory (os error 21)".to_string()
-      );
+      assert_eq!(e.to_string(), "Is a directory (os error 21)".to_string());
     }
   }
 }

tauri-api/src/http.rs

@@ -265,7 +265,9 @@ pub fn make_request(options: HttpRequestOptions) -> crate::Result<Value> {
         if let Some(path) = body.as_str() {
           builder.file(File::open(path)?).send()
         } else {
-          return Err(crate::Error::Path("Body must be the path to the file".into()).into());
+          return Err(crate::Error::Path(
+            "Body must be the path to the file".into(),
+          ));
         }
       }
       BodyType::Auto => {
@@ -297,6 +299,6 @@ pub fn make_request(options: HttpRequestOptions) -> crate::Result<Value> {
     };
     Ok(response_data)
   } else {
-    Err(crate::Error::Network(response.status()).into())
+    Err(response.status().into())
   }
 }

tauri-api/src/lib.rs

@@ -36,32 +36,12 @@ pub mod notification;
 
 pub use tauri_utils::*;
 
-/// Alias for a Result with error type anyhow::Error.
-pub use anyhow::Result;
-use thiserror::Error;
+mod error;
 
-/// The error types.
-#[derive(Error, Debug)]
-pub enum Error {
-  /// The extract archive error.
-  #[error("Extract Error:{0}")]
-  Extract(String),
-  /// The Command (spawn process) error.
-  #[error("Command Error:{0}")]
-  Command(String),
-  /// The file operation error.
-  #[error("File Error:{0}")]
-  File(String),
-  /// The path operation error.
-  #[error("Path Error:{0}")]
-  Path(String),
-  /// The dialog error.
-  #[error("Dialog Error:{0}")]
-  Dialog(String),
-  /// The network error.
-  #[error("Network Error:{0}")]
-  Network(attohttpc::StatusCode),
-}
+/// Tauri API error.
+pub use error::Error;
+/// Tauri API result type.
+pub type Result<T> = std::result::Result<T, Error>;
 
 // Not public API
 #[doc(hidden)]

tauri-api/src/notification.rs

@@ -77,9 +77,7 @@ impl Notification {
         notification.app_id(&self.identifier);
       }
     }
-    notification
-      .show()
-      .map(|_| ())
-      .map_err(|e| anyhow::anyhow!(e.to_string()))
+    notification.show()?;
+    Ok(())
   }
 }

tauri-api/src/path.rs

@@ -84,7 +84,9 @@ pub fn resolve_path<P: AsRef<Path>>(path: P, dir: Option<BaseDirectory>) -> crat
       base_dir_path_value.push(path);
       Ok(base_dir_path_value)
     } else {
-      Err(crate::Error::Path("unable to determine base dir path".to_string()).into())
+      Err(crate::Error::Path(
+        "unable to determine base dir path".to_string(),
+      ))
     }
   } else {
     let mut dir_path = PathBuf::new();

tauri-macros/src/expand.rs

@@ -21,10 +21,8 @@ pub(crate) fn load_context(input: DeriveInput) -> Result<TokenStream, Error> {
     .iter()
     .find(|attr| attr.path.is_ident("config_path"));
   if let Some(attr) = config_path_attr {
-    if let Ok(meta) = attr.parse_meta() {
-      if let NameValue(MetaNameValue { lit: Str(path), .. }) = meta {
-        config_file_path = path.value()
-      }
+    if let Ok(NameValue(MetaNameValue { lit: Str(path), .. })) = attr.parse_meta() {
+      config_file_path = path.value()
     }
   }
 

tauri-utils/Cargo.toml

@@ -12,7 +12,6 @@ edition = "2018"
 serde = "1.0"
 serde_json = "1.0"
 sysinfo = "0.10"
-anyhow = "1.0.31"
 thiserror = "1.0.19"
 phf = { version = "0.8", features = ["macros"] }
 flate2 = "1"

tauri-utils/src/lib.rs

@@ -10,11 +10,11 @@ pub mod platform;
 /// Process helpers
 pub mod process;
 
-pub use anyhow::Result;
-use thiserror::Error;
+/// Result type alias using the crate's error type.
+pub type Result<T> = std::result::Result<T, Error>;
 
 /// The error types.
-#[derive(Error, Debug)]
+#[derive(Debug, thiserror::Error)]
 pub enum Error {
   /// Target triple architecture error
   #[error("Unable to determine target-architecture")]
@@ -25,9 +25,9 @@ pub enum Error {
   /// Target triple environment error
   #[error("Unable to determine target-environment")]
   Environment,
-  /// Target triple unknown target-os error
-  #[error("Unknown target_os")]
-  Unknown,
+  /// Tried to get resource on an unsupported platform.
+  #[error("Unsupported platform for reading resources")]
+  UnsupportedPlatform,
   /// Get parent process error
   #[error("Could not get parent process")]
   ParentProcess,
@@ -37,4 +37,7 @@ pub enum Error {
   /// Get child process error
   #[error("Could not get child process")]
   ChildProcess,
+  /// IO error.
+  #[error("{0}")]
+  Io(#[from] std::io::Error),
 }