[rust] Errors implementing Deserializer/Serializer on Error enum

[angelhdzmultimedia]

I'm writing commands. Followed this section https://tauri.app/v1/guides/features/command#error-handling
because the return type of my command functions needs to impl Deserializer/Serializer. So I did:

#[derive(Debug, thiserror::Error)]
enum Error {
  #[error(transparent)]
  Io(#[from] std::io::Error)
}

// we must manually implement serde::Serialize
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())
  }
}

// Commands

 #[tauri::command]
 fn writeFile(fileData: FileData) -> Result<(), Error>  {
  ensure_dir("./data");
  let mut file = fs::File::create(fileData.path).expect("IO Error");
    file.write(fileData.data.as_bytes()).expect("IO Error");
    Ok(())
}

error[E0433]: failed to resolve: use of undeclared crate or module `thiserror`
  --> src\main.rs:28:17
   |
28 | #[derive(Debug, thiserror::Error)]
   |                 ^^^^^^^^^ use of undeclared crate or module `thiserror`

error: cannot find attribute `error` in this scope
  --> src\main.rs:30:5
   |
30 |   #[error(transparent)]
   |     ^^^^^

error: cannot find attribute `from` in this scope
  --> src\main.rs:31:8
   |
31 |   Io(#[from] std::io::Error)
   |        ^^^^

warning: unused import: `serde_json`
 --> src\main.rs:5:5
  |
5 | use serde_json;
  |     ^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused import: `std::collections::HashMap`
 --> src\main.rs:6:5
  |
6 | use std::collections::HashMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `std::io`
 --> src\main.rs:8:5
  |
8 | use std::io;
  |     ^^^^^^^

error[E0599]: the method `to_string` exists for reference `&Error`, but its trait bounds were not satisfied
   --> src\main.rs:40:35
    |
29  | enum Error {
    | ----------
    | |
    | doesn't satisfy `Error: ToString`
    | doesn't satisfy `Error: std::fmt::Display`
...
40  |     serializer.serialize_str(self.to_string().as_ref())
    |                                   ^^^^^^^^^ method cannot be called on `&Error` due to unsatisfied trait bounds
    |
    = note: the following trait bounds were not satisfied:
            `Error: std::fmt::Display`
            which is required by `Error: ToString`
            `&Error: std::fmt::Display`
            which is required by `&Error: ToString`
note: the trait `std::fmt::Display` must be implemented
   --> C:\Users\AngelHdz\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\core\src\fmt\mod.rs:672:1
    |
672 | pub trait Display {
    | ^^^^^^^^^^^^^^^^^

Some errors have detailed explanations: E0433, E0599.
For more information about an error, try `rustc --explain E0433`.
warning: `app` (bin "app") generated 3 warnings
error: could not compile `app` (bin "app") due to 4 previous errors; 3 warnings emitted

Starting with Rust and Tauri. Give me a hand please! 😁🤝🔥💛🩵

[FabianLars]

Please add thiserror = "1" to the dependencies section in Cargo.toml.

I will keep this in mind for the new docs, thanks :)

[angelhdzmultimedia]

Life saver! Woo hoo! Hahaha! 🔥💛💚🤯🤝😁

Tauri is awesome.

// Prevents additional console window on Windows in release, DO NOT REMOVE!!
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]


use serde_json;
use std::collections::HashMap;
use std::fs;
use std::io;
use std::io::Write;
use std::path;
use std::process::Command;

#[derive(serde::Serialize, serde::Deserialize, Debug)]
struct User {
  name: String,
}

type Users = Vec<User>;


#[derive(serde::Deserialize)]
struct FileData {
  path: String,
  content: String,
}


#[derive(Debug, thiserror::Error)]
enum Error {
  #[error(transparent)]
  Io(#[from] std::io::Error)
}

// we must manually implement serde::Serialize
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())
  }
}


 #[tauri::command]
 fn writeFile(fileData: FileData) -> Result<(), Error>  {

  ensure_dir("./data");
  println!("Writing file: {}", fileData.path);
  let mut file = fs::File::create(format!("./data/{}", fileData.path)).expect("IO Error");
    file.write(fileData.content.as_bytes()).expect("IO Error");
    Ok(())
}
 

 fn ensure_dir(path: &str) -> bool {
  let _path: &path::Path = path::Path::new(path);
   if !_path.exists() {
    println!("Creating directory: {}", path);
    fs::create_dir(path).unwrap();
     return true
   }
   return false
 } 

fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![writeFile])
        .run(tauri::generate_context!())
        .expect("error while running tauri application"); 
    
}