Remove tokio thread spawn & improve error handling

src-tauri/Cargo.toml

@@ -27,6 +27,7 @@ serde_bencode = "0.2.3"
 zstd = "0.12.3"
 lazy_static = "1.4.0"
 open = "5.0.0"
+thiserror = "1.0.40"
 
 [features]
 # this feature is used for production builds or when `devPath` points to the filesystem

src-tauri/src/errors.rs

@@ -0,0 +1,16 @@
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[error("{0}")]
+    Custom(String),
+}
+
+impl serde::Serialize for Error {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: serde::ser::Serializer,
+    {
+        serializer.serialize_str(self.to_string().as_ref())
+    }
+}

src-tauri/src/filesystem/mod.rs

@@ -1,12 +1,9 @@
 pub mod cache;
 pub mod volume;
 
-use std::fmt::Debug;
 use crate::filesystem::volume::DirectoryChild;
 use std::fs::read_dir;
-use std::io;
-use std::io::{ErrorKind, Error};
-use std::process::ExitStatus;
+use crate::errors::Error;
 
 pub const DIRECTORY: &str = "directory";
 pub const FILE: &str = "file";
@@ -18,20 +15,22 @@ pub const fn bytes_to_gb(bytes: u64) -> u16 {
 /// Opens a file at the given path. Returns a string if there was an error.
 // NOTE(conaticus): I tried handling the errors nicely here but Tauri was mega cringe and wouldn't let me nest results in async functions, so used string error messages instead.
 #[tauri::command]
-pub async fn open_file(path: String) -> Result<String, ()> {
-    Ok(tokio::task::spawn_blocking(move || {
-        let output_res = open::commands(path)[0].output();
-        let output = match output_res {
-            Ok(output) => output,
-            Err(err) => return format!("Failed to get open command output: {}", err)
-        };
-
-        if output.status.success() {
-            return String::new();
+pub async fn open_file(path: String) -> Result<(), Error> {
+    let output_res = open::commands(path)[0].output();
+    let output = match output_res {
+        Ok(output) => output,
+        Err(err) => {
+            let err_msg = format!("Failed to get open command output: {}", err);
+            return Err(Error::Custom(err_msg));
         }
+    };
+
+    if output.status.success() {
+        return Ok(());
+    }
 
-        String::from_utf8(output.stderr).unwrap_or(String::from("Failed to open file and deserialize stderr."))
-    }).await.unwrap_or(String::from("Failed to create tokio thread when opening file.")))
+    let err_msg = String::from_utf8(output.stderr).unwrap_or(String::from("Failed to open file and deserialize stderr."));
+    Err(Error::Custom(err_msg))
 }
 
 /// Searches and returns the files in a given directory. This is not recursive.

src-tauri/src/main.rs

@@ -3,6 +3,7 @@
 
 mod filesystem;
 mod search;
+mod errors;
 
 use filesystem::{open_directory, open_file};
 use filesystem::volume::get_volumes;

src/components/MainBody/DirectoryContents.tsx

@@ -9,10 +9,7 @@ interface Props {
 
 export function DirectoryContents({content, onDirectoryClick}: Props) {
     async function onFileClick(path: string) {
-        const err = await openFile(path);
-        if (err.length != 0) {
-            alert(err);
-        }
+        await openFile(path).catch(err => alert(err));
     }
 
     return <>