use std::{fmt, ops::Deref};
use axum::{
extract::{FromRequestParts, Query},
http::request::Parts,
};
use serde::{
Deserialize, Deserializer,
de::{self, DeserializeOwned},
};
use crate::http::{ApiProblem, ProblemCode, RequestContext};
#[derive(Clone)]
pub struct QueryParams<T>(T);
impl<T> fmt::Debug for QueryParams<T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_tuple("QueryParams")
.field(&"[REDACTED]")
.finish()
}
}
impl<T> QueryParams<T> {
#[must_use]
pub const fn get(&self) -> &T {
&self.0
}
#[must_use]
pub fn into_inner(self) -> T {
self.0
}
}
impl<T> AsRef<T> for QueryParams<T> {
fn as_ref(&self) -> &T {
self.get()
}
}
impl<T> Deref for QueryParams<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
self.get()
}
}
impl<S, T> FromRequestParts<S> for QueryParams<T>
where
S: Send + Sync,
T: DeserializeOwned,
{
type Rejection = ApiProblem;
async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
let context = context_from_parts(parts);
let Query(query) =
Query::<T>::from_request_parts(parts, state)
.await
.map_err(|rejection| {
ApiProblem::bad_request(
ProblemCode::from_static("invalid_query"),
rejection.to_string(),
)
.with_request_context(&context)
})?;
Ok(Self(query))
}
}
#[derive(Debug, Deserialize)]
#[serde(untagged)]
enum StringOrU32 {
Number(u32),
String(String),
}
#[derive(Debug, Deserialize)]
#[serde(untagged)]
enum StringOrBool {
Bool(bool),
String(String),
}
pub fn deserialize_optional_u32_from_query<'de, D>(deserializer: D) -> Result<Option<u32>, D::Error>
where
D: Deserializer<'de>,
{
match Option::<StringOrU32>::deserialize(deserializer)? {
Some(StringOrU32::Number(value)) => Ok(Some(value)),
Some(StringOrU32::String(value)) => parse_optional_query_u32(&value),
None => Ok(None),
}
}
pub fn deserialize_bool_from_query<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
D: Deserializer<'de>,
{
match StringOrBool::deserialize(deserializer)? {
StringOrBool::Bool(value) => Ok(value),
StringOrBool::String(value) => parse_query_bool(&value),
}
}
fn parse_optional_query_u32<E>(value: &str) -> Result<Option<u32>, E>
where
E: de::Error,
{
let value = value.trim();
if value.is_empty() {
return Ok(None);
}
value
.parse::<u32>()
.map(Some)
.map_err(|_| E::custom("expected unsigned integer query parameter"))
}
fn parse_query_bool<E>(value: &str) -> Result<bool, E>
where
E: de::Error,
{
match value.trim().to_ascii_lowercase().as_str() {
"true" | "1" => Ok(true),
"false" | "0" => Ok(false),
_ => Err(E::custom("expected boolean query parameter")),
}
}
fn context_from_parts(parts: &Parts) -> RequestContext {
parts
.extensions
.get::<RequestContext>()
.cloned()
.unwrap_or_else(|| RequestContext::from_headers(&parts.headers))
}
#[cfg(test)]
mod tests {
use super::QueryParams;
#[test]
fn query_params_debug_redacts_inner_values() {
let value = "private-query-value";
let query = QueryParams(value.to_owned());
let debug = format!("{query:?}");
assert!(debug.contains("[REDACTED]"));
assert!(!debug.contains(value));
assert_eq!(query.get(), value);
}
}