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}