Skip to main content

yaiko_core/
extract.rs

1//! Typed request extraction primitives for Yaiko handlers.
2
3use crate::{AppError, AppResult, Request};
4use serde::de::DeserializeOwned;
5
6/// Trait implemented by values that can be extracted from an inbound request.
7#[async_trait::async_trait]
8pub trait FromRequest: Sized {
9    async fn from_request(request: &mut Request) -> AppResult<Self>;
10}
11
12/// Extract and deserialize a JSON request body.
13pub struct Json<T>(pub T);
14
15#[async_trait::async_trait]
16impl<T> FromRequest for Json<T>
17where
18    T: DeserializeOwned + Send,
19{
20    async fn from_request(request: &mut Request) -> AppResult<Self> {
21        let value = request.json().await.map_err(AppError::from)?;
22        serde_json::from_value(value)
23            .map(Json)
24            .map_err(AppError::from)
25    }
26}
27
28/// Extract and deserialize query parameters.
29pub struct Query<T>(pub T);
30
31#[async_trait::async_trait]
32impl<T> FromRequest for Query<T>
33where
34    T: DeserializeOwned + Send,
35{
36    async fn from_request(request: &mut Request) -> AppResult<Self> {
37        serde_json::to_value(&request.query)
38            .map_err(AppError::from)
39            .and_then(|value| {
40                serde_json::from_value(value)
41                    .map(Query)
42                    .map_err(AppError::from)
43            })
44    }
45}
46
47/// Extract and deserialize route path parameters.
48pub struct Path<T>(pub T);
49
50#[async_trait::async_trait]
51impl<T> FromRequest for Path<T>
52where
53    T: DeserializeOwned + Send,
54{
55    async fn from_request(request: &mut Request) -> AppResult<Self> {
56        serde_json::to_value(&request.params)
57            .map_err(AppError::from)
58            .and_then(|value| {
59                serde_json::from_value(value)
60                    .map(Path)
61                    .map_err(AppError::from)
62            })
63    }
64}
65
66/// Extract URL-encoded form fields.
67pub struct Form<T>(pub T);
68
69#[async_trait::async_trait]
70impl<T> FromRequest for Form<T>
71where
72    T: DeserializeOwned + Send,
73{
74    async fn from_request(request: &mut Request) -> AppResult<Self> {
75        let fields = request.form_data().await.map_err(AppError::from)?;
76        serde_json::to_value(fields)
77            .map_err(AppError::from)
78            .and_then(|value| {
79                serde_json::from_value(value)
80                    .map(Form)
81                    .map_err(AppError::from)
82            })
83    }
84}
85
86#[cfg(test)]
87mod tests {
88    use super::*;
89    use hyper::Body;
90    use serde::Deserialize;
91
92    #[derive(Debug, Deserialize, PartialEq)]
93    struct Payload {
94        title: String,
95    }
96
97    #[tokio::test]
98    async fn json_extractor_deserializes_request_body() {
99        let hyper_request = hyper::Request::builder()
100            .method("POST")
101            .uri("/items")
102            .header("content-type", "application/json")
103            .body(Body::from(r#"{"title":"hello"}"#))
104            .unwrap();
105        let mut request = Request::from_hyper(hyper_request).await.unwrap();
106
107        let Json(payload) = Json::<Payload>::from_request(&mut request).await.unwrap();
108        assert_eq!(
109            payload,
110            Payload {
111                title: "hello".into()
112            }
113        );
114    }
115
116    #[tokio::test]
117    async fn query_extractor_deserializes_query_map() {
118        #[derive(Debug, Deserialize, PartialEq)]
119        struct Filters {
120            page: String,
121        }
122
123        let hyper_request = hyper::Request::builder()
124            .uri("/items?page=2")
125            .body(Body::empty())
126            .unwrap();
127        let mut request = Request::from_hyper(hyper_request).await.unwrap();
128        let Query(filters) = Query::<Filters>::from_request(&mut request).await.unwrap();
129        assert_eq!(filters, Filters { page: "2".into() });
130    }
131}