workflow-store 0.19.0

File storage access crate abstracting file I/O and browser localstorage
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//!
//!  Errors produced by this crate.
//!

use base64::DecodeError;
use thiserror::Error;
use wasm_bindgen::prelude::*;
use workflow_wasm::jserror::*;

/// Errors produced by the `workflow-store` crate.
#[derive(Error, Debug)]
pub enum Error {
    /// A custom, free-form error message.
    #[error("{0}")]
    Custom(String),

    /// An underlying file system I/O error.
    #[error("I/O error: {0}")]
    IoError(#[from] std::io::Error),

    /// An error originating from the Chrome extension storage backend.
    #[error("Chrome error: {0}")]
    ChromeError(#[from] workflow_chrome::error::Error),

    // #[error("JavaScript error: {0:?}")]
    // JsValue(Sendable<JsValue>),
    /// An error captured from a JavaScript exception or rejected promise.
    #[error("{0}")]
    JsValue(JsErrorData),

    /// A Base64 string could not be decoded.
    #[error("Base64 decode error: {0}")]
    DecodeError(DecodeError),

    /// The requested file or storage key does not exist.
    #[error("Not found: {0}")]
    NotFound(String),

    /// The stored data was expected to be a UTF-8 string but is not.
    #[error("Not a text data: {0}")]
    DataIsNotAString(String),

    /// The stored data was expected to be a binary buffer but is not.
    #[error("Not a buffer data: {0}")]
    DataIsNotABuffer(String),

    /// A JSON serialization or deserialization error.
    #[error(transparent)]
    SerdeJson(#[from] serde_json::Error),

    /// The supplied path is malformed or otherwise invalid.
    #[error("invalid path: {0}")]
    InvalidPath(String),

    /// The user's home directory could not be determined.
    #[error("Unable to obtain user home directory")]
    HomeDir(String),

    /// File metadata is unavailable.
    #[error("No file metadata")]
    Metadata,

    /// A hex encoding or decoding error.
    #[error(transparent)]
    FasterHex(#[from] faster_hex::Error),

    /// The requested operation is not supported in the current environment.
    #[error("This operation is not supported")]
    NotSupported,
}

impl From<Error> for JsValue {
    fn from(err: Error) -> Self {
        match err {
            Error::JsValue(js_err) => js_err.into(),
            _ => err.into(),
        }
    }
}

// impl From<Error> for JsErrorData {
//     fn from(err: Error) -> Self {
//         match err {
//             Error::JsValue(js_err) => js_err.into(),
//             _ => err.into(),
//         }
//     }
// }

impl From<JsValue> for Error {
    fn from(error: JsValue) -> Error {
        Error::JsValue(error.into())
    }
}

impl From<JsErrorData> for Error {
    fn from(error: JsErrorData) -> Error {
        Error::JsValue(error)
    }
}

impl From<DecodeError> for Error {
    fn from(error: DecodeError) -> Error {
        Error::DecodeError(error)
    }
}

impl From<String> for Error {
    fn from(error: String) -> Error {
        Error::Custom(error)
    }
}

impl Error {
    /// Returns the error code carried by an underlying JavaScript error,
    /// or `None` for error variants that do not have one.
    pub fn code(&self) -> Option<&str> {
        match self {
            Error::JsValue(js_err) => js_err.code().as_deref(),
            _ => None,
        }
    }
}