use std::any::Any;
use std::collections::HashMap;
use std::fmt;
use std::sync::Arc;
fn parse_bearer_token(value: &str) -> Option<&str> {
let mut parts = value.split_whitespace();
let scheme = parts.next()?;
let token = parts.next()?;
if parts.next().is_some() || !scheme.eq_ignore_ascii_case("Bearer") {
return None;
}
Some(token)
}
pub struct Request {
pub body: serde_json::Value,
pub headers: HashMap<String, String>,
pub query: HashMap<String, String>,
pub path_params: HashMap<String, String>,
resource_guards: Vec<Arc<dyn Any + Send + Sync>>,
}
impl Clone for Request {
fn clone(&self) -> Self {
Self {
body: self.body.clone(),
headers: self.headers.clone(),
query: self.query.clone(),
path_params: self.path_params.clone(),
resource_guards: Vec::new(),
}
}
}
impl Request {
pub fn new(body: serde_json::Value) -> Self {
Self {
body,
headers: HashMap::new(),
query: HashMap::new(),
path_params: HashMap::new(),
resource_guards: Vec::new(),
}
}
pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
let name = name.into();
let name = name.trim();
if name.is_empty() {
return self;
}
self.headers.insert(name.to_ascii_lowercase(), value.into());
self
}
pub fn headers(mut self, headers: HashMap<String, String>) -> Self {
for (name, value) in headers {
self = self.header(name, value);
}
self
}
pub fn query(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
let key = key.into();
let key = key.trim();
if key.is_empty() {
return self;
}
self.query.insert(key.to_string(), value.into());
self
}
pub fn queries(mut self, query: HashMap<String, String>) -> Self {
for (key, value) in query {
self = self.query(key, value);
}
self
}
pub fn path_param(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
let key = key.into();
let key = key.trim();
if key.is_empty() {
return self;
}
self.path_params.insert(key.to_string(), value.into());
self
}
pub fn path_params(mut self, path_params: HashMap<String, String>) -> Self {
for (key, value) in path_params {
self = self.path_param(key, value);
}
self
}
#[cfg(feature = "transport-axum")]
pub(crate) fn retain_resource<T>(mut self, resource: Arc<T>) -> Self
where
T: Any + Send + Sync,
{
self.resource_guards.push(resource);
self
}
pub fn token(&self) -> Option<&str> {
self.get_header("authorization")
.and_then(parse_bearer_token)
}
pub fn user_agent(&self) -> Option<&str> {
self.get_header("user-agent")
}
pub fn cookie(&self) -> Option<&str> {
self.get_header("cookie")
}
pub fn get_header(&self, name: &str) -> Option<&str> {
let name = name.trim();
if name.is_empty() {
return None;
}
self.headers
.get(name)
.or_else(|| {
self.headers
.iter()
.find_map(|(key, value)| key.eq_ignore_ascii_case(name).then_some(value))
})
.map(|s| s.as_str())
}
pub fn get_query(&self, key: &str) -> Option<&str> {
let key = key.trim();
if key.is_empty() {
return None;
}
self.query.get(key).map(|s| s.as_str())
}
pub fn get_path_param(&self, key: &str) -> Option<&str> {
let key = key.trim();
if key.is_empty() {
return None;
}
self.path_params.get(key).map(|s| s.as_str())
}
}
struct RedactedMap<'a>(&'a HashMap<String, String>);
impl fmt::Debug for RedactedMap<'_> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut map = formatter.debug_map();
for key in self.0.keys() {
map.entry(key, &"[REDACTED]");
}
map.finish()
}
}
struct RedactedBody<'a>(&'a serde_json::Value);
fn body_shape_summary(value: &serde_json::Value) -> String {
match value {
serde_json::Value::Null => "null".to_string(),
serde_json::Value::Bool(_) => "bool".to_string(),
serde_json::Value::Number(_) => "number".to_string(),
serde_json::Value::String(value) => format!("string(len={})", value.len()),
serde_json::Value::Array(values) => format!("array(len={})", values.len()),
serde_json::Value::Object(map) => format!("object(keys={})", map.len()),
}
}
impl fmt::Debug for RedactedBody<'_> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.0 {
serde_json::Value::Object(map) => {
let mut summary = formatter.debug_map();
for (key, value) in map {
let shape = body_shape_summary(value);
summary.entry(key, &format!("[REDACTED:{shape}]"));
}
summary.finish()
}
value => write!(formatter, "[REDACTED:{}]", body_shape_summary(value)),
}
}
}
impl fmt::Debug for Request {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Request")
.field("body", &RedactedBody(&self.body))
.field("headers", &RedactedMap(&self.headers))
.field("query", &RedactedMap(&self.query))
.field("path_params", &RedactedMap(&self.path_params))
.field("resource_guard_count", &self.resource_guards.len())
.finish()
}
}
impl Default for Request {
fn default() -> Self {
Self::new(serde_json::Value::Null)
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[cfg(feature = "transport-axum")]
use std::sync::atomic::{AtomicUsize, Ordering};
#[cfg(feature = "transport-axum")]
struct DropResource(Arc<AtomicUsize>);
#[cfg(feature = "transport-axum")]
impl Drop for DropResource {
fn drop(&mut self) {
self.0.fetch_add(1, Ordering::SeqCst);
}
}
#[test]
fn test_header_lookup_is_case_insensitive() {
let request = Request::new(json!({}))
.header("Content-Type", "application/json")
.header("aUtHoRiZaTiOn", "Bearer token123");
assert_eq!(request.get_header("content-type"), Some("application/json"));
assert_eq!(request.get_header("AUTHORIZATION"), Some("Bearer token123"));
assert_eq!(request.token(), Some("token123"));
}
#[test]
#[cfg(feature = "transport-axum")]
fn clone_does_not_extend_request_scoped_resource_lifetime() {
let drops = Arc::new(AtomicUsize::new(0));
let resource = Arc::new(DropResource(Arc::clone(&drops)));
let request = Request::new(json!({})).retain_resource(Arc::clone(&resource));
drop(resource);
let cloned = request.clone();
drop(request);
assert_eq!(drops.load(Ordering::SeqCst), 1);
drop(cloned);
assert_eq!(drops.load(Ordering::SeqCst), 1);
}
#[test]
fn test_header_insert_normalizes_name_and_overwrites_case_variants() {
let request = Request::new(json!({}))
.header("Authorization", "Bearer old")
.header("authorization", "Bearer new");
assert_eq!(request.headers.len(), 1);
assert_eq!(
request.headers.get("authorization").map(String::as_str),
Some("Bearer new")
);
assert_eq!(request.get_header("Authorization"), Some("Bearer new"));
assert_eq!(request.token(), Some("new"));
}
#[test]
fn test_header_trims_name_before_normalizing() {
let request = Request::new(json!({})).header(" Authorization ", "Bearer token123");
assert_eq!(request.headers.len(), 1);
assert_eq!(request.get_header("authorization"), Some("Bearer token123"));
assert_eq!(
request.get_header(" Authorization "),
Some("Bearer token123")
);
assert_eq!(request.token(), Some("token123"));
}
#[test]
fn test_header_rejects_blank_names() {
let request = Request::new(json!({}))
.header("", "empty")
.header(" ", "blank")
.header("X-Request-Id", "abc");
assert_eq!(request.get_header("x-request-id"), Some("abc"));
assert_eq!(request.get_header(""), None);
assert_eq!(request.get_header(" "), None);
}
#[test]
fn test_get_header_rejects_blank_names() {
let mut request = Request::new(json!({}));
request.headers.insert("".to_string(), "empty".to_string());
request
.headers
.insert(" ".to_string(), "blank".to_string());
request
.headers
.insert("x-request-id".to_string(), "abc".to_string());
assert_eq!(request.get_header("x-request-id"), Some("abc"));
assert_eq!(request.get_header(""), None);
assert_eq!(request.get_header(" "), None);
}
#[test]
fn test_token_accepts_case_insensitive_bearer_scheme() {
let lower = Request::new(json!({})).header("authorization", "bearer lower-token");
let upper = Request::new(json!({})).header("authorization", "BEARER upper-token");
assert_eq!(lower.token(), Some("lower-token"));
assert_eq!(upper.token(), Some("upper-token"));
}
#[test]
fn test_token_trims_scheme_spacing_and_rejects_empty_or_split_token() {
let padded = Request::new(json!({})).header("authorization", "Bearer padded-token");
let empty = Request::new(json!({})).header("authorization", "Bearer ");
let split = Request::new(json!({})).header("authorization", "Bearer token extra");
assert_eq!(padded.token(), Some("padded-token"));
assert_eq!(empty.token(), None);
assert_eq!(split.token(), None);
}
#[test]
fn test_query_rejects_blank_keys() {
let request = Request::new(json!({}))
.query("", "empty")
.query(" ", "blank")
.query("page", "1");
let mut query = std::collections::HashMap::new();
query.insert("".to_string(), "empty-bulk".to_string());
query.insert(" ".to_string(), "blank-bulk".to_string());
query.insert("limit".to_string(), "10".to_string());
let request = request.queries(query);
assert_eq!(request.get_query("page"), Some("1"));
assert_eq!(request.get_query("limit"), Some("10"));
assert_eq!(request.get_query(""), None);
assert_eq!(request.get_query(" "), None);
}
#[test]
fn test_query_trims_keys_before_storing() {
let request = Request::new(json!({})).query(" page ", "1");
assert_eq!(request.query.len(), 1);
assert_eq!(request.get_query("page"), Some("1"));
assert_eq!(request.get_query(" page "), Some("1"));
}
#[test]
fn test_get_query_rejects_blank_keys() {
let mut request = Request::new(json!({}));
request.query.insert("".to_string(), "empty".to_string());
request.query.insert(" ".to_string(), "blank".to_string());
request.query.insert("page".to_string(), "1".to_string());
assert_eq!(request.get_query("page"), Some("1"));
assert_eq!(request.get_query(""), None);
assert_eq!(request.get_query(" "), None);
}
#[test]
fn test_path_param_rejects_blank_keys() {
let request = Request::new(json!({}))
.path_param("", "empty")
.path_param(" ", "blank")
.path_param("id", "42");
let mut path_params = std::collections::HashMap::new();
path_params.insert("".to_string(), "empty-bulk".to_string());
path_params.insert(" ".to_string(), "blank-bulk".to_string());
path_params.insert("slug".to_string(), "demo".to_string());
let request = request.path_params(path_params);
assert_eq!(request.get_path_param("id"), Some("42"));
assert_eq!(request.get_path_param("slug"), Some("demo"));
assert_eq!(request.get_path_param(""), None);
assert_eq!(request.get_path_param(" "), None);
}
#[test]
fn test_path_param_trims_keys_before_storing() {
let request = Request::new(json!({})).path_param(" id ", "42");
assert_eq!(request.path_params.len(), 1);
assert_eq!(request.get_path_param("id"), Some("42"));
assert_eq!(request.get_path_param(" id "), Some("42"));
}
#[test]
fn test_get_path_param_rejects_blank_keys() {
let mut request = Request::new(json!({}));
request
.path_params
.insert("".to_string(), "empty".to_string());
request
.path_params
.insert(" ".to_string(), "blank".to_string());
request
.path_params
.insert("id".to_string(), "42".to_string());
assert_eq!(request.get_path_param("id"), Some("42"));
assert_eq!(request.get_path_param(""), None);
assert_eq!(request.get_path_param(" "), None);
}
#[test]
fn debug_redacts_request_body_values() {
let request = Request::new(json!({
"username": "alice",
"password": "body-password-secret",
"refresh_token": "body-refresh-secret",
"nested": { "code": "body-code-secret" },
"items": ["body-list-secret"],
}))
.header("Authorization", "Bearer header-secret")
.query("access_token", "query-secret")
.path_param("session", "path-secret");
let debug = format!("{request:?}");
for secret in [
"alice",
"body-password-secret",
"body-refresh-secret",
"body-code-secret",
"body-list-secret",
"header-secret",
"query-secret",
"path-secret",
] {
assert!(
!debug.contains(secret),
"Request Debug 泄露 {secret}: {debug}"
);
}
assert!(debug.contains("password"), "应保留 body 键名: {debug}");
assert!(debug.contains("string(len="), "应保留长度摘要: {debug}");
assert!(debug.contains("object(keys=1)"), "应保留类型摘要: {debug}");
assert!(debug.contains("[REDACTED]"), "{debug}");
}
}