resty 0.1.4

A fast, concurrent and multi-threadable REST 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
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

use std::ops::{Deref, DerefMut};

use smol::io::AsyncReadExt;
use url::Url;

use crate::{Error, HttpMethod};

pub type Readable = std::pin::Pin<Box<dyn smol::io::AsyncRead + Send>>;

/// An partially parsed Request with headers, cookies and path parameters.  
///
/// The request body is read lazily
pub struct Request<'a> {
    pub headers: &'a [httparse::Header<'a>],
    pub url: &'a Url,
    pub cookies: &'a Vec<(&'a str, &'a str)>,
    pub path_params: &'a Vec<&'a str>,
    pub method: HttpMethod,
    pub version: u8,
    body: Option<Result<Box<[u8]>, Error>>,
    readable: &'a mut Readable,
}

impl<'a> Request<'a> {
    pub async fn new(
        request: &'a httparse::Request<'a, 'a>,
        url: &'a Url,
        cookies: &'a Vec<(&'a str, &'a str)>,
        path_params: &'a Vec<&'a str>,
        readable: &'a mut Readable,
    ) -> Result<Self, Error> {
        Ok(Self {
            method: request.method.ok_or(Error::RequestError)?.into(),
            url,
            cookies,
            version: request.version.ok_or(Error::RequestError)?,
            headers: request.headers,
            readable,
            path_params,
            body: None,
        })
    }

    pub async fn body<B: Deserialize>(&mut self) -> Result<B, Error> {
        if let Some(ref body) = self.body {
            return body.as_ref().map_err(|e| e.clone()).and_then(|body| {
                B::deserialize(&body).map_err(|e| Error::ParseError(e.to_string()))
            });
        }

        let Some(content_length) = self
            .headers
            .iter()
            .find(|h| h.name.to_ascii_lowercase() == "content-length")
            .map(|h| h.value)
        else {
            self.body.replace(Err(Error::MissingContentLength));
            return Err(Error::MissingContentLength);
        };

        let Some(bytes) = str::from_utf8(content_length)
            .ok()
            .and_then(|content_length| usize::from_str_radix(content_length, 10).ok())
        else {
            self.body.replace(Err(Error::InvalidContentLength));
            return Err(Error::InvalidContentLength);
        };

        let mut vec = vec![0; bytes].into_boxed_slice();

        let _ = self.read_exact(&mut vec).await;

        let res = B::deserialize(&vec).map_err(|e| Error::ParseError(e.to_string()));

        self.body.replace(Ok(vec));

        res
    }
}

impl Deref for Request<'_> {
    type Target = std::pin::Pin<Box<dyn smol::io::AsyncRead + Send>>;

    fn deref(&self) -> &Self::Target {
        &self.readable
    }
}

impl DerefMut for Request<'_> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.readable
    }
}

// impl<'a, 'b: 'a> Request<'b> {
//     pub fn as_typed(&'a mut self) -> Request<'a> {
//         Request {
//             headers: self.headers,
//             url: self.url,
//             cookies: self.cookies,
//             path_params: self.path_params,
//             method: self.method,
//             version: self.version,
//             readable: self.readable,
//             body: None,
//         }
//     }
// }

#[doc = include_str!("../docs/traits/Deserialize.md")]
pub trait Deserialize
where
    Self: Sized,
{
    fn deserialize(data: &[u8]) -> Result<Self, Box<dyn std::error::Error>>;
}

impl Deserialize for () {
    fn deserialize(_: &[u8]) -> Result<Self, Box<dyn std::error::Error>> {
        Err(Error::UnTypedRequest)?
    }
}