thiserror typesafe error handling example

examples/app/src-tauri/Cargo.toml

@@ -19,6 +19,7 @@ serde = { version = "1.0", features = ["derive"] }
 tauri = { version = "2.0.0-beta", features = [] }
 tauri-specta = { path = "../../../", features = ["typescript", "javascript"] }
 tauri-plugin-os = "2.0.0-beta.3"
+thiserror = "1.0.60"
 
 [features]
 default = ["custom-protocol"]

examples/app/src-tauri/src/main.rs

@@ -6,6 +6,7 @@
 use serde::{Deserialize, Serialize};
 use specta::{Type, TypeCollection};
 use tauri_specta::*;
+use thiserror::Error;
 
 /// HELLO
 /// WORLD
@@ -54,6 +55,29 @@ mod nested {
     }
 }
 
+#[derive(Error, Debug, Serialize, Type)]
+pub enum MyError {
+    // On the frontend this variant will be "IoError" with no data.
+    #[error("io error: {0}")]
+    IoError(
+        #[serde(skip)] // io::Error is not `Serialize` or `Type`
+        #[from]
+        std::io::Error,
+    ),
+    // On the frontend this variant will be "AnotherError" with string data.
+    #[error("some other error: {0}")]
+    AnotherError(String),
+}
+
+#[tauri::command]
+#[specta::specta]
+fn typesafe_errors_using_thiserror() -> Result<(), MyError> {
+    Err(MyError::IoError(std::io::Error::new(
+        std::io::ErrorKind::Other,
+        "oh no!",
+    )))
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, specta::Type, tauri_specta::Event)]
 pub struct DemoEvent(String);
 
@@ -63,18 +87,17 @@ pub struct EmptyEvent;
 #[derive(Type)]
 pub struct Custom(String);
 
-// We recommend re-using the builder via a macro rather than function as the builder's
-// generics can be tricky to deal with
-macro_rules! specta_builder {
-    () => {{
+fn main() {
+    let (invoke_handler, register_events) = {
         let builder = ts::builder()
             .commands(tauri_specta::collect_commands![
                 hello_world,
                 goodbye_world,
                 has_error,
                 nested::some_struct,
                 generic::<tauri::Wry>,
-                deprecated
+                deprecated,
+                typesafe_errors_using_thiserror
             ])
             .events(tauri_specta::collect_events![DemoEvent, EmptyEvent])
             .types(TypeCollection::default().register::<Custom>())
@@ -83,12 +106,8 @@ macro_rules! specta_builder {
         #[cfg(debug_assertions)]
         let builder = builder.path("../src/bindings.ts");
 
-        builder
-    }};
-}
-
-fn main() {
-    let (invoke_handler, register_events) = specta_builder!().build().unwrap();
+        builder.build().unwrap()
+    };
 
     tauri::Builder::default()
         .invoke_handler(invoke_handler)

examples/app/src/bindings.ts

@@ -24,13 +24,21 @@ async someStruct() : Promise<MyStruct> {
 return await TAURI_INVOKE("some_struct");
 },
 async generic() : Promise<void> {
-
+await TAURI_INVOKE("generic");
 },
 /**
  * @deprecated This is a deprecated function
  */
 async deprecated() : Promise<void> {
-
+await TAURI_INVOKE("deprecated");
+},
+async typesafeErrorsUsingThiserror() : Promise<Result<null, MyError>> {
+try {
+    return { status: "ok", data: await TAURI_INVOKE("typesafe_errors_using_thiserror") };
+} catch (e) {
+    if(e instanceof Error) throw e;
+    else return { status: "error", error: e  as any };
+}
 }
 }
 
@@ -47,6 +55,7 @@ emptyEvent: "empty-event"
 export type Custom = string
 export type DemoEvent = string
 export type EmptyEvent = null
+export type MyError = "IoError" | { AnotherError: string }
 export type MyStruct = { some_field: string }
 
 /** tauri-specta globals **/