footing 0.1.0

Feature-gated foundations for Rust backend services
Documentation
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)]
/// Represents query params.
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]
    /// Returns the parsed query value.
    pub const fn get(&self) -> &T {
        &self.0
    }

    #[must_use]
    /// Consumes this value and returns inner.
    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),
}

/// Deserializes an optional `u32` from a URL query scalar.
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),
    }
}

/// Deserializes a boolean from a URL query scalar.
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);
    }
}