1use crate::{AppError, AppResult, Request};
4use serde::de::DeserializeOwned;
5
6#[async_trait::async_trait]
8pub trait FromRequest: Sized {
9 async fn from_request(request: &mut Request) -> AppResult<Self>;
10}
11
12pub 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
28pub 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
47pub 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
66pub 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}