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
470struct RedactedBody<'a>(&'a serde_json::Value);
476
477fn body_shape_summary(value: &serde_json::Value) -> String {
479 match value {
480 serde_json::Value::Null => "null".to_string(),
481 serde_json::Value::Bool(_) => "bool".to_string(),
482 serde_json::Value::Number(_) => "number".to_string(),
483 serde_json::Value::String(value) => format!("string(len={})", value.len()),
484 serde_json::Value::Array(values) => format!("array(len={})", values.len()),
485 serde_json::Value::Object(map) => format!("object(keys={})", map.len()),
486 }
487}
488
489impl fmt::Debug for RedactedBody<'_> {
490 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
491 match self.0 {
492 serde_json::Value::Object(map) => {
493 let mut summary = formatter.debug_map();
494 for (key, value) in map {
495 let shape = body_shape_summary(value);
496 summary.entry(key, &format!("[REDACTED:{shape}]"));
497 }
498 summary.finish()
499 }
500 value => write!(formatter, "[REDACTED:{}]", body_shape_summary(value)),
501 }
502 }
503}
504
505impl fmt::Debug for Request {
506 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
507 formatter
508 .debug_struct("Request")
509 .field("body", &RedactedBody(&self.body))
510 .field("headers", &RedactedMap(&self.headers))
511 .field("query", &RedactedMap(&self.query))
512 .field("path_params", &RedactedMap(&self.path_params))
513 .field("resource_guard_count", &self.resource_guards.len())
514 .finish()
515 }
516}
517
518impl Default for Request {
519 fn default() -> Self {
520 Self::new(serde_json::Value::Null)
521 }
522}
523
524#[cfg(test)]
525mod tests {
526 use super::*;
527 use serde_json::json;
528 #[cfg(feature = "transport-axum")]
529 use std::sync::atomic::{AtomicUsize, Ordering};
530
531 #[cfg(feature = "transport-axum")]
532 struct DropResource(Arc<AtomicUsize>);
533
534 #[cfg(feature = "transport-axum")]
535 impl Drop for DropResource {
536 fn drop(&mut self) {
537 self.0.fetch_add(1, Ordering::SeqCst);
538 }
539 }
540
541 #[test]
542 fn test_header_lookup_is_case_insensitive() {
543 let request = Request::new(json!({}))
544 .header("Content-Type", "application/json")
545 .header("aUtHoRiZaTiOn", "Bearer token123");
546
547 assert_eq!(request.get_header("content-type"), Some("application/json"));
548 assert_eq!(request.get_header("AUTHORIZATION"), Some("Bearer token123"));
549 assert_eq!(request.token(), Some("token123"));
550 }
551
552 #[test]
553 #[cfg(feature = "transport-axum")]
554 fn clone_does_not_extend_request_scoped_resource_lifetime() {
555 let drops = Arc::new(AtomicUsize::new(0));
556 let resource = Arc::new(DropResource(Arc::clone(&drops)));
557 let request = Request::new(json!({})).retain_resource(Arc::clone(&resource));
558 drop(resource);
559 let cloned = request.clone();
560
561 drop(request);
562 assert_eq!(drops.load(Ordering::SeqCst), 1);
563 drop(cloned);
564 assert_eq!(drops.load(Ordering::SeqCst), 1);
565 }
566
567 #[test]
568 fn test_header_insert_normalizes_name_and_overwrites_case_variants() {
569 let request = Request::new(json!({}))
570 .header("Authorization", "Bearer old")
571 .header("authorization", "Bearer new");
572
573 assert_eq!(request.headers.len(), 1);
574 assert_eq!(
575 request.headers.get("authorization").map(String::as_str),
576 Some("Bearer new")
577 );
578 assert_eq!(request.get_header("Authorization"), Some("Bearer new"));
579 assert_eq!(request.token(), Some("new"));
580 }
581
582 #[test]
583 fn test_header_trims_name_before_normalizing() {
584 let request = Request::new(json!({})).header(" Authorization ", "Bearer token123");
585
586 assert_eq!(request.headers.len(), 1);
587 assert_eq!(request.get_header("authorization"), Some("Bearer token123"));
588 assert_eq!(
589 request.get_header(" Authorization "),
590 Some("Bearer token123")
591 );
592 assert_eq!(request.token(), Some("token123"));
593 }
594
595 #[test]
596 fn test_header_rejects_blank_names() {
597 let request = Request::new(json!({}))
598 .header("", "empty")
599 .header(" ", "blank")
600 .header("X-Request-Id", "abc");
601
602 assert_eq!(request.get_header("x-request-id"), Some("abc"));
603 assert_eq!(request.get_header(""), None);
604 assert_eq!(request.get_header(" "), None);
605 }
606
607 #[test]
608 fn test_get_header_rejects_blank_names() {
609 let mut request = Request::new(json!({}));
610 request.headers.insert("".to_string(), "empty".to_string());
611 request
612 .headers
613 .insert(" ".to_string(), "blank".to_string());
614 request
615 .headers
616 .insert("x-request-id".to_string(), "abc".to_string());
617
618 assert_eq!(request.get_header("x-request-id"), Some("abc"));
619 assert_eq!(request.get_header(""), None);
620 assert_eq!(request.get_header(" "), None);
621 }
622
623 #[test]
624 fn test_token_accepts_case_insensitive_bearer_scheme() {
625 let lower = Request::new(json!({})).header("authorization", "bearer lower-token");
626 let upper = Request::new(json!({})).header("authorization", "BEARER upper-token");
627
628 assert_eq!(lower.token(), Some("lower-token"));
629 assert_eq!(upper.token(), Some("upper-token"));
630 }
631
632 #[test]
633 fn test_token_trims_scheme_spacing_and_rejects_empty_or_split_token() {
634 let padded = Request::new(json!({})).header("authorization", "Bearer padded-token");
635 let empty = Request::new(json!({})).header("authorization", "Bearer ");
636 let split = Request::new(json!({})).header("authorization", "Bearer token extra");
637
638 assert_eq!(padded.token(), Some("padded-token"));
639 assert_eq!(empty.token(), None);
640 assert_eq!(split.token(), None);
641 }
642
643 #[test]
644 fn test_query_rejects_blank_keys() {
645 let request = Request::new(json!({}))
646 .query("", "empty")
647 .query(" ", "blank")
648 .query("page", "1");
649
650 let mut query = std::collections::HashMap::new();
651 query.insert("".to_string(), "empty-bulk".to_string());
652 query.insert(" ".to_string(), "blank-bulk".to_string());
653 query.insert("limit".to_string(), "10".to_string());
654
655 let request = request.queries(query);
656
657 assert_eq!(request.get_query("page"), Some("1"));
658 assert_eq!(request.get_query("limit"), Some("10"));
659 assert_eq!(request.get_query(""), None);
660 assert_eq!(request.get_query(" "), None);
661 }
662
663 #[test]
664 fn test_query_trims_keys_before_storing() {
665 let request = Request::new(json!({})).query(" page ", "1");
666
667 assert_eq!(request.query.len(), 1);
668 assert_eq!(request.get_query("page"), Some("1"));
669 assert_eq!(request.get_query(" page "), Some("1"));
670 }
671
672 #[test]
673 fn test_get_query_rejects_blank_keys() {
674 let mut request = Request::new(json!({}));
675 request.query.insert("".to_string(), "empty".to_string());
676 request.query.insert(" ".to_string(), "blank".to_string());
677 request.query.insert("page".to_string(), "1".to_string());
678
679 assert_eq!(request.get_query("page"), Some("1"));
680 assert_eq!(request.get_query(""), None);
681 assert_eq!(request.get_query(" "), None);
682 }
683
684 #[test]
685 fn test_path_param_rejects_blank_keys() {
686 let request = Request::new(json!({}))
687 .path_param("", "empty")
688 .path_param(" ", "blank")
689 .path_param("id", "42");
690
691 let mut path_params = std::collections::HashMap::new();
692 path_params.insert("".to_string(), "empty-bulk".to_string());
693 path_params.insert(" ".to_string(), "blank-bulk".to_string());
694 path_params.insert("slug".to_string(), "demo".to_string());
695
696 let request = request.path_params(path_params);
697
698 assert_eq!(request.get_path_param("id"), Some("42"));
699 assert_eq!(request.get_path_param("slug"), Some("demo"));
700 assert_eq!(request.get_path_param(""), None);
701 assert_eq!(request.get_path_param(" "), None);
702 }
703
704 #[test]
705 fn test_path_param_trims_keys_before_storing() {
706 let request = Request::new(json!({})).path_param(" id ", "42");
707
708 assert_eq!(request.path_params.len(), 1);
709 assert_eq!(request.get_path_param("id"), Some("42"));
710 assert_eq!(request.get_path_param(" id "), Some("42"));
711 }
712
713 #[test]
714 fn test_get_path_param_rejects_blank_keys() {
715 let mut request = Request::new(json!({}));
716 request
717 .path_params
718 .insert("".to_string(), "empty".to_string());
719 request
720 .path_params
721 .insert(" ".to_string(), "blank".to_string());
722 request
723 .path_params
724 .insert("id".to_string(), "42".to_string());
725
726 assert_eq!(request.get_path_param("id"), Some("42"));
727 assert_eq!(request.get_path_param(""), None);
728 assert_eq!(request.get_path_param(" "), None);
729 }
730
731 #[test]
732 fn debug_redacts_request_body_values() {
733 let request = Request::new(json!({
736 "username": "alice",
737 "password": "body-password-secret",
738 "refresh_token": "body-refresh-secret",
739 "nested": { "code": "body-code-secret" },
740 "items": ["body-list-secret"],
741 }))
742 .header("Authorization", "Bearer header-secret")
743 .query("access_token", "query-secret")
744 .path_param("session", "path-secret");
745
746 let debug = format!("{request:?}");
747 for secret in [
748 "alice",
749 "body-password-secret",
750 "body-refresh-secret",
751 "body-code-secret",
752 "body-list-secret",
753 "header-secret",
754 "query-secret",
755 "path-secret",
756 ] {
757 assert!(
758 !debug.contains(secret),
759 "Request Debug 泄露 {secret}: {debug}"
760 );
761 }
762 assert!(debug.contains("password"), "应保留 body 键名: {debug}");
764 assert!(debug.contains("string(len="), "应保留长度摘要: {debug}");
765 assert!(debug.contains("object(keys=1)"), "应保留类型摘要: {debug}");
766 assert!(debug.contains("[REDACTED]"), "{debug}");
767 }
768}