forked from cloudflare/workers-rs
-
Notifications
You must be signed in to change notification settings - Fork 0
/
error.rs
111 lines (98 loc) · 3.01 KB
/
error.rs
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
use wasm_bindgen::{JsCast, JsValue};
/// All possible Error variants that might be encountered while working with a Worker.
#[derive(Debug)]
#[non_exhaustive]
pub enum Error {
BadEncoding,
BodyUsed,
Json((String, u16)),
JsError(String),
Internal(JsValue),
Io(std::io::Error),
BindingError(String),
RouteInsertError(matchit::InsertError),
RouteNoDataError,
RustError(String),
SerdeJsonError(serde_json::Error),
#[cfg(feature = "queue")]
SerdeWasmBindgenError(serde_wasm_bindgen::Error),
}
impl From<worker_kv::KvError> for Error {
fn from(e: worker_kv::KvError) -> Self {
let val: JsValue = e.into();
val.into()
}
}
impl From<url::ParseError> for Error {
fn from(e: url::ParseError) -> Self {
Self::RustError(e.to_string())
}
}
impl From<serde_wasm_bindgen::Error> for Error {
fn from(e: serde_wasm_bindgen::Error) -> Self {
let val: JsValue = e.into();
val.into()
}
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::BadEncoding => write!(f, "content-type mismatch"),
Error::BodyUsed => write!(f, "body has already been read"),
Error::Json((msg, status)) => write!(f, "{msg} (status: {status})"),
Error::JsError(s) | Error::RustError(s) => {
write!(f, "{s}")
}
Error::Internal(_) => write!(f, "unrecognized JavaScript object"),
Error::Io(e) => write!(f, "IO Error: {e}"),
Error::BindingError(name) => write!(f, "no binding found for `{name}`"),
Error::RouteInsertError(e) => write!(f, "failed to insert route: {e}"),
Error::RouteNoDataError => write!(f, "route has no corresponding shared data"),
Error::SerdeJsonError(e) => write!(f, "Serde Error: {e}"),
#[cfg(feature = "queue")]
Error::SerdeWasmBindgenError(e) => write!(f, "Serde Error: {e}"),
}
}
}
impl std::error::Error for Error {}
impl From<JsValue> for Error {
fn from(v: JsValue) -> Self {
match v
.as_string()
.or_else(|| v.dyn_ref::<js_sys::Error>().map(|e| e.to_string().into()))
{
Some(s) => Self::JsError(s),
None => Self::Internal(v),
}
}
}
impl From<std::io::Error> for Error {
fn from(error: std::io::Error) -> Self {
Self::Io(error)
}
}
impl From<Error> for JsValue {
fn from(e: Error) -> Self {
JsValue::from_str(&e.to_string())
}
}
impl From<&str> for Error {
fn from(a: &str) -> Self {
Error::RustError(a.to_string())
}
}
impl From<String> for Error {
fn from(a: String) -> Self {
Error::RustError(a)
}
}
impl From<matchit::InsertError> for Error {
fn from(e: matchit::InsertError) -> Self {
Error::RouteInsertError(e)
}
}
impl From<serde_json::Error> for Error {
fn from(e: serde_json::Error) -> Self {
Error::SerdeJsonError(e)
}
}