routerify_query/lib.rs
1//! A [`Routerify`](https://github.com/routerify/routerify) middleware which parses the request query string and populates in the `req` object.
2//!
3//! # Examples
4//!
5//! ```no_run
6//! use hyper::{Body, Request, Response, Server};
7//! use routerify::{Router, RouterService};
8//! // Import the query_parser function and the RequestQueryExt trait.
9//! use routerify_query::{query_parser, RequestQueryExt};
10//! use std::{convert::Infallible, net::SocketAddr};
11//!
12//! // A handler for "/" page. Visit: "/?username=Alice&bookname=HarryPotter" to see query values.
13//! async fn home_handler(req: Request<Body>) -> Result<Response<Body>, Infallible> {
14//! // Access the query values.
15//! let user_name = req.query("username").unwrap();
16//! let book_name = req.query("bookname").unwrap();
17//!
18//! Ok(Response::new(Body::from(format!(
19//! "User: {}, Book: {}",
20//! user_name, book_name
21//! ))))
22//! }
23//!
24//! // Create a router.
25//! fn router() -> Router<Body, Infallible> {
26//! Router::builder()
27//! // Attach the query_parser middleware.
28//! .middleware(query_parser())
29//! .get("/", home_handler)
30//! .build()
31//! .unwrap()
32//! }
33//!
34//! #[tokio::main]
35//! async fn main() {
36//! let router = router();
37//!
38//! // Create a Service from the router above to handle incoming requests.
39//! let service = RouterService::new(router).unwrap();
40//!
41//! // The address on which the server will be listening.
42//! let addr = SocketAddr::from(([127, 0, 0, 1], 3001));
43//!
44//! // Create a server by passing the created service to `.serve` method.
45//! let server = Server::bind(&addr).serve(service);
46//!
47//! println!("App is running on: {}", addr);
48//! if let Err(err) = server.await {
49//! eprintln!("Server error: {}", err);
50//! }
51//! }
52//! ```
53//!
54
55use hyper::{body::HttpBody, Request};
56use routerify::Middleware;
57use std::collections::HashMap;
58use url::form_urlencoded;
59
60pub use ext::RequestQueryExt;
61
62mod ext;
63
64#[derive(Debug, Clone)]
65pub(crate) struct Query(pub HashMap<String, String>);
66
67/// Parses the request query string and populates in the `req` object.
68///
69/// # Examples
70///
71/// ```
72/// use hyper::{Body, Request, Response, Server};
73/// use routerify::{Router, RouterService};
74/// // Import the query_parser function and the RequestQueryExt trait.
75/// use routerify_query::{query_parser, RequestQueryExt};
76/// use std::{convert::Infallible, net::SocketAddr};
77///
78/// // A handler for "/" page. Visit: "/?username=Alice&bookname=HarryPotter" to see query values.
79/// async fn home_handler(req: Request<Body>) -> Result<Response<Body>, Infallible> {
80/// // Access the query values.
81/// let user_name = req.query("username").unwrap();
82/// let book_name = req.query("bookname").unwrap();
83///
84/// Ok(Response::new(Body::from(format!(
85/// "User: {}, Book: {}",
86/// user_name, book_name
87/// ))))
88/// }
89///
90///
91/// # fn run() -> Router<Body, Infallible> {
92/// // Create a router.
93/// Router::builder()
94/// // Attach the query_parser middleware.
95/// .middleware(query_parser())
96/// .get("/", home_handler)
97/// .build()
98/// .unwrap()
99/// }
100/// # run();
101/// ```
102pub fn query_parser<B, E>() -> Middleware<B, E>
103where
104 B: HttpBody + Send + Sync + Unpin + 'static,
105 E: std::error::Error + Send + Sync + Unpin + 'static,
106{
107 Middleware::pre(query_parser_middleware_handler::<E>)
108}
109
110async fn query_parser_middleware_handler<E>(mut req: Request<hyper::Body>) -> Result<Request<hyper::Body>, E>
111where
112 E: std::error::Error + Send + Sync + Unpin + 'static,
113{
114 let mut q = Query(HashMap::new());
115
116 if let Some(query_str) = req.uri().query() {
117 q = Query(form_urlencoded::parse(query_str.as_bytes()).into_owned().collect());
118 }
119
120 req.extensions_mut().insert(q);
121
122 Ok(req)
123}