1use std::any::Any;
6use std::collections::HashMap;
7use std::fmt;
8use std::sync::Arc;
9
10fn parse_bearer_token(value: &str) -> Option<&str> {
11 let mut parts = value.split_whitespace();
12 let scheme = parts.next()?;
13 let token = parts.next()?;
14
15 if parts.next().is_some() || !scheme.eq_ignore_ascii_case("Bearer") {
16 return None;
17 }
18
19 Some(token)
20}
21
22pub struct Request {
63 pub body: serde_json::Value,
65
66 pub headers: HashMap<String, String>,
68
69 pub query: HashMap<String, String>,
71
72 pub path_params: HashMap<String, String>,
74
75 resource_guards: Vec<Arc<dyn Any + Send + Sync>>,
77}
78
79impl Clone for Request {
80 fn clone(&self) -> Self {
81 Self {
82 body: self.body.clone(),
83 headers: self.headers.clone(),
84 query: self.query.clone(),
85 path_params: self.path_params.clone(),
86 resource_guards: Vec::new(),
88 }
89 }
90}
91
92impl Request {
93 pub fn new(body: serde_json::Value) -> Self {
115 Self {
116 body,
117 headers: HashMap::new(),
118 query: HashMap::new(),
119 path_params: HashMap::new(),
120 resource_guards: Vec::new(),
121 }
122 }
123
124 pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
146 let name = name.into();
147 let name = name.trim();
148 if name.is_empty() {
149 return self;
150 }
151
152 self.headers.insert(name.to_ascii_lowercase(), value.into());
153 self
154 }
155
156 pub fn headers(mut self, headers: HashMap<String, String>) -> Self {
181 for (name, value) in headers {
182 self = self.header(name, value);
183 }
184 self
185 }
186
187 pub fn query(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
209 let key = key.into();
210 let key = key.trim();
211 if key.is_empty() {
212 return self;
213 }
214
215 self.query.insert(key.to_string(), value.into());
216 self
217 }
218
219 pub fn queries(mut self, query: HashMap<String, String>) -> Self {
244 for (key, value) in query {
245 self = self.query(key, value);
246 }
247 self
248 }
249
250 pub fn path_param(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
272 let key = key.into();
273 let key = key.trim();
274 if key.is_empty() {
275 return self;
276 }
277
278 self.path_params.insert(key.to_string(), value.into());
279 self
280 }
281
282 pub fn path_params(mut self, path_params: HashMap<String, String>) -> Self {
307 for (key, value) in path_params {
308 self = self.path_param(key, value);
309 }
310 self
311 }
312
313 #[cfg(feature = "transport-axum")]
314 pub(crate) fn retain_resource<T>(mut self, resource: Arc<T>) -> Self
315 where
316 T: Any + Send + Sync,
317 {
318 self.resource_guards.push(resource);
319 self
320 }
321
322 pub fn token(&self) -> Option<&str> {
343 self.get_header("authorization")
344 .and_then(parse_bearer_token)
345 }
346
347 pub fn user_agent(&self) -> Option<&str> {
349 self.get_header("user-agent")
350 }
351
352 pub fn cookie(&self) -> Option<&str> {
354 self.get_header("cookie")
355 }
356
357 pub fn get_header(&self, name: &str) -> Option<&str> {
380 let name = name.trim();
381 if name.is_empty() {
382 return None;
383 }
384
385 self.headers
386 .get(name)
387 .or_else(|| {
388 self.headers
389 .iter()
390 .find_map(|(key, value)| key.eq_ignore_ascii_case(name).then_some(value))
391 })
392 .map(|s| s.as_str())
393 }
394
395 pub fn get_query(&self, key: &str) -> Option<&str> {
418 let key = key.trim();
419 if key.is_empty() {
420 return None;
421 }
422
423 self.query.get(key).map(|s| s.as_str())
424 }
425
426 pub fn get_path_param(&self, key: &str) -> Option<&str> {
449 let key = key.trim();
450 if key.is_empty() {
451 return None;
452 }
453
454 self.path_params.get(key).map(|s| s.as_str())
455 }
456}
457
458struct RedactedMap<'a>(&'a HashMap<String, String>);
459
460impl fmt::Debug for RedactedMap<'_> {
461 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
462 let mut map = formatter.debug_map();
463 for key in self.0.keys() {
464 map.entry(key, &"[REDACTED]");
465 }
466 map.finish()
467 }
468}
469
470impl fmt::Debug for Request {
471 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
472 formatter
473 .debug_struct("Request")
474 .field("body", &self.body)
475 .field("headers", &RedactedMap(&self.headers))
476 .field("query", &RedactedMap(&self.query))
477 .field("path_params", &RedactedMap(&self.path_params))
478 .field("resource_guard_count", &self.resource_guards.len())
479 .finish()
480 }
481}
482
483impl Default for Request {
484 fn default() -> Self {
485 Self::new(serde_json::Value::Null)
486 }
487}
488
489#[cfg(test)]
490mod tests {
491 use super::*;
492 use serde_json::json;
493 #[cfg(feature = "transport-axum")]
494 use std::sync::atomic::{AtomicUsize, Ordering};
495
496 #[cfg(feature = "transport-axum")]
497 struct DropResource(Arc<AtomicUsize>);
498
499 #[cfg(feature = "transport-axum")]
500 impl Drop for DropResource {
501 fn drop(&mut self) {
502 self.0.fetch_add(1, Ordering::SeqCst);
503 }
504 }
505
506 #[test]
507 fn test_header_lookup_is_case_insensitive() {
508 let request = Request::new(json!({}))
509 .header("Content-Type", "application/json")
510 .header("aUtHoRiZaTiOn", "Bearer token123");
511
512 assert_eq!(request.get_header("content-type"), Some("application/json"));
513 assert_eq!(request.get_header("AUTHORIZATION"), Some("Bearer token123"));
514 assert_eq!(request.token(), Some("token123"));
515 }
516
517 #[test]
518 #[cfg(feature = "transport-axum")]
519 fn clone_does_not_extend_request_scoped_resource_lifetime() {
520 let drops = Arc::new(AtomicUsize::new(0));
521 let resource = Arc::new(DropResource(Arc::clone(&drops)));
522 let request = Request::new(json!({})).retain_resource(Arc::clone(&resource));
523 drop(resource);
524 let cloned = request.clone();
525
526 drop(request);
527 assert_eq!(drops.load(Ordering::SeqCst), 1);
528 drop(cloned);
529 assert_eq!(drops.load(Ordering::SeqCst), 1);
530 }
531
532 #[test]
533 fn test_header_insert_normalizes_name_and_overwrites_case_variants() {
534 let request = Request::new(json!({}))
535 .header("Authorization", "Bearer old")
536 .header("authorization", "Bearer new");
537
538 assert_eq!(request.headers.len(), 1);
539 assert_eq!(
540 request.headers.get("authorization").map(String::as_str),
541 Some("Bearer new")
542 );
543 assert_eq!(request.get_header("Authorization"), Some("Bearer new"));
544 assert_eq!(request.token(), Some("new"));
545 }
546
547 #[test]
548 fn test_header_trims_name_before_normalizing() {
549 let request = Request::new(json!({})).header(" Authorization ", "Bearer token123");
550
551 assert_eq!(request.headers.len(), 1);
552 assert_eq!(request.get_header("authorization"), Some("Bearer token123"));
553 assert_eq!(
554 request.get_header(" Authorization "),
555 Some("Bearer token123")
556 );
557 assert_eq!(request.token(), Some("token123"));
558 }
559
560 #[test]
561 fn test_header_rejects_blank_names() {
562 let request = Request::new(json!({}))
563 .header("", "empty")
564 .header(" ", "blank")
565 .header("X-Request-Id", "abc");
566
567 assert_eq!(request.get_header("x-request-id"), Some("abc"));
568 assert_eq!(request.get_header(""), None);
569 assert_eq!(request.get_header(" "), None);
570 }
571
572 #[test]
573 fn test_get_header_rejects_blank_names() {
574 let mut request = Request::new(json!({}));
575 request.headers.insert("".to_string(), "empty".to_string());
576 request
577 .headers
578 .insert(" ".to_string(), "blank".to_string());
579 request
580 .headers
581 .insert("x-request-id".to_string(), "abc".to_string());
582
583 assert_eq!(request.get_header("x-request-id"), Some("abc"));
584 assert_eq!(request.get_header(""), None);
585 assert_eq!(request.get_header(" "), None);
586 }
587
588 #[test]
589 fn test_token_accepts_case_insensitive_bearer_scheme() {
590 let lower = Request::new(json!({})).header("authorization", "bearer lower-token");
591 let upper = Request::new(json!({})).header("authorization", "BEARER upper-token");
592
593 assert_eq!(lower.token(), Some("lower-token"));
594 assert_eq!(upper.token(), Some("upper-token"));
595 }
596
597 #[test]
598 fn test_token_trims_scheme_spacing_and_rejects_empty_or_split_token() {
599 let padded = Request::new(json!({})).header("authorization", "Bearer padded-token");
600 let empty = Request::new(json!({})).header("authorization", "Bearer ");
601 let split = Request::new(json!({})).header("authorization", "Bearer token extra");
602
603 assert_eq!(padded.token(), Some("padded-token"));
604 assert_eq!(empty.token(), None);
605 assert_eq!(split.token(), None);
606 }
607
608 #[test]
609 fn test_query_rejects_blank_keys() {
610 let request = Request::new(json!({}))
611 .query("", "empty")
612 .query(" ", "blank")
613 .query("page", "1");
614
615 let mut query = std::collections::HashMap::new();
616 query.insert("".to_string(), "empty-bulk".to_string());
617 query.insert(" ".to_string(), "blank-bulk".to_string());
618 query.insert("limit".to_string(), "10".to_string());
619
620 let request = request.queries(query);
621
622 assert_eq!(request.get_query("page"), Some("1"));
623 assert_eq!(request.get_query("limit"), Some("10"));
624 assert_eq!(request.get_query(""), None);
625 assert_eq!(request.get_query(" "), None);
626 }
627
628 #[test]
629 fn test_query_trims_keys_before_storing() {
630 let request = Request::new(json!({})).query(" page ", "1");
631
632 assert_eq!(request.query.len(), 1);
633 assert_eq!(request.get_query("page"), Some("1"));
634 assert_eq!(request.get_query(" page "), Some("1"));
635 }
636
637 #[test]
638 fn test_get_query_rejects_blank_keys() {
639 let mut request = Request::new(json!({}));
640 request.query.insert("".to_string(), "empty".to_string());
641 request.query.insert(" ".to_string(), "blank".to_string());
642 request.query.insert("page".to_string(), "1".to_string());
643
644 assert_eq!(request.get_query("page"), Some("1"));
645 assert_eq!(request.get_query(""), None);
646 assert_eq!(request.get_query(" "), None);
647 }
648
649 #[test]
650 fn test_path_param_rejects_blank_keys() {
651 let request = Request::new(json!({}))
652 .path_param("", "empty")
653 .path_param(" ", "blank")
654 .path_param("id", "42");
655
656 let mut path_params = std::collections::HashMap::new();
657 path_params.insert("".to_string(), "empty-bulk".to_string());
658 path_params.insert(" ".to_string(), "blank-bulk".to_string());
659 path_params.insert("slug".to_string(), "demo".to_string());
660
661 let request = request.path_params(path_params);
662
663 assert_eq!(request.get_path_param("id"), Some("42"));
664 assert_eq!(request.get_path_param("slug"), Some("demo"));
665 assert_eq!(request.get_path_param(""), None);
666 assert_eq!(request.get_path_param(" "), None);
667 }
668
669 #[test]
670 fn test_path_param_trims_keys_before_storing() {
671 let request = Request::new(json!({})).path_param(" id ", "42");
672
673 assert_eq!(request.path_params.len(), 1);
674 assert_eq!(request.get_path_param("id"), Some("42"));
675 assert_eq!(request.get_path_param(" id "), Some("42"));
676 }
677
678 #[test]
679 fn test_get_path_param_rejects_blank_keys() {
680 let mut request = Request::new(json!({}));
681 request
682 .path_params
683 .insert("".to_string(), "empty".to_string());
684 request
685 .path_params
686 .insert(" ".to_string(), "blank".to_string());
687 request
688 .path_params
689 .insert("id".to_string(), "42".to_string());
690
691 assert_eq!(request.get_path_param("id"), Some("42"));
692 assert_eq!(request.get_path_param(""), None);
693 assert_eq!(request.get_path_param(" "), None);
694 }
695}