lieweb 0.2.0

a simple async web framework
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

#[derive(thiserror::Error, Debug)]
pub enum Error {
    #[error("hyper error")]
    HyperError(#[from] hyper::Error),
    #[error("io error")]
    IOError(#[from] std::io::Error),
    #[error("http error")]
    HttpError(#[from] hyper::http::Error),
    #[error("serde_json error")]
    JsonError(#[from] serde_json::Error),
    #[error("serde_urlencoded decode error")]
    FormDecodeError(#[from] serde_urlencoded::de::Error),
    #[error("serde_urlencoded decode error")]
    FormEncodeError(#[from] serde_urlencoded::ser::Error),
    #[error("infallible")]
    Infallible(#[from] std::convert::Infallible),
    #[error("mime error")]
    Mime(#[from] mime::FromStrError),
    #[error("lieweb error")]
    Message(String),
    #[error("invalid request header {name:?}")]
    InvalidHeader { name: &'static str },
    #[error("invalid param {name:?} as {expected:?}, {err:?}")]
    InvalidParam {
        name: String,
        expected: &'static str,
        err: String,
    },
    #[error("missing AppState {name:?}")]
    MissingAppState { name: &'static str },
    #[error("missing url param {name:?}")]
    MissingParam { name: String },
    #[error("missing cookie {name:?}")]
    MissingCookie { name: String },
    #[error("missing header {name:?}")]
    MissingHeader { name: String },
    #[cfg(feature = "tls")]
    #[error("tls error")]
    TlsError(#[from] tokio_rustls::rustls::Error),
}

impl<'a> From<&'a str> for Error {
    fn from(s: &'a str) -> Self {
        Error::Message(s.to_string())
    }
}

impl From<String> for Error {
    fn from(s: String) -> Self {
        Error::Message(s)
    }
}

#[macro_export]
macro_rules! error_msg {
    ($msg:literal) => {
        $crate::Error::Message($msg.to_string())
    };
    ($fmt:expr, $($arg:tt)*) => {
        $crate::Error::Message(format!($fmt, $($arg)*))
    };
}

pub fn invalid_header(name: &'static str) -> Error {
    Error::InvalidHeader { name }
}

pub fn invalid_param(
    name: impl ToString,
    expected: &'static str,
    err: impl std::error::Error,
) -> Error {
    Error::InvalidParam {
        name: name.to_string(),
        expected,
        err: err.to_string(),
    }
}

pub fn missing_cookie(name: impl ToString) -> Error {
    Error::MissingCookie {
        name: name.to_string(),
    }
}

pub fn missing_header(name: impl ToString) -> Error {
    Error::MissingHeader {
        name: name.to_string(),
    }
}

pub fn missing_param(name: impl ToString) -> Error {
    Error::MissingParam {
        name: name.to_string(),
    }
}