chore: Copy-paste QsQuery from serde_qs to prepare migration to Axum 0.8

`serde_qs` is unmaintained and depending on the `axum` feature would prevent us from upgrading Axum.

Author: RemiBardon

Cargo.lock

@@ -35,7 +35,7 @@ lazy_static = { workspace = true }
 secrecy = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-serde_qs = { workspace = true, features = ["axum"] }
+serde_qs = { workspace = true }
 serde_with = { workspace = true }
 service = { workspace = true }
 strum = { workspace = true, features = ["derive"] }

crates/rest-api/Cargo.toml

@@ -6,6 +6,7 @@
 mod interval;
 mod pagination;
 pub mod qs_query;
+mod strict_qs_query;
 mod timestamp;
 
 pub use interval::Interval;

crates/rest-api/src/forms/mod.rs

@@ -8,9 +8,10 @@ use std::{borrow::Cow, collections::HashSet};
 use axum::{
     body::Body,
     extract::{FromRequestParts, Query as AxumQuery},
-    http::{uri, Request},
+    http::{request::Parts, uri, Request},
 };
-use serde_qs::axum::{QsQuery as StrictQsQuery, QsQueryRejection};
+
+use super::strict_qs_query::{QsQuery as StrictQsQuery, QsQueryRejection};
 
 /// Like [`serde_qs::axum::QsQuery`], but also supports non-bracketed parameters for arrays.
 pub struct QsQuery<T>(pub T);
@@ -81,10 +82,7 @@ where
 {
     type Rejection = QsQueryRejection;
 
-    async fn from_request_parts(
-        parts: &mut axum::http::request::Parts,
-        state: &S,
-    ) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
         match StrictQsQuery::<T>::from_request_parts(parts, state).await {
             Ok(StrictQsQuery(res)) => Ok(Self(res)),
             // NOTE: In most cases, `StrictQsQuery` will work because `rename_repeated_query_param_names`
@@ -109,6 +107,20 @@ where
     }
 }
 
+// #[axum::async_trait]
+// impl<T, S> FromRequestParts<S> for StrictQsQuery<T>
+// where
+//     T: serde::de::DeserializeOwned,
+// {
+//     type Rejection = QsQueryRejection;
+
+//     async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
+//         // TODO: error handling
+//         let query = parts.uri.query().unwrap();
+//         Ok(Self(serde_qs::from_str(query).unwrap()))
+//     }
+// }
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/rest-api/src/forms/qs_query.rs

@@ -0,0 +1,228 @@
+//! Functionality for using `serde_qs` with `axum`.
+//!
+//! Source: https://github.com/samscott89/serde_qs/blob/b7278b73c637f7c427be762082fee5938ba0c023/src/axum.rs
+//! NOTE: The source was copy-pasted here because `serde_qs` is unmaintained and this implementation
+//!   would prevent us from upgrading Axum.
+//! NOTE: We could also use the simpler approach from https://github.com/tokio-rs/axum/issues/434#issuecomment-954898159
+
+use std::sync::Arc;
+
+use serde_qs::{Config as QsConfig, Error as QsError};
+
+use axum::{
+    extract::{Extension, FromRequestParts},
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    BoxError, Error,
+};
+
+#[derive(Clone, Copy, Default)]
+/// Extract typed information from from the request's query.
+///
+/// ## Example
+///
+/// ```rust
+/// # extern crate axum_framework as axum;
+/// use serde_qs::axum::QsQuery;
+/// use serde_qs::Config;
+/// use axum::{response::IntoResponse, routing::get, Router, body::Body};
+///
+/// #[derive(serde::Deserialize)]
+/// pub struct UsersFilter {
+///    id: Vec<u64>,
+/// }
+///
+/// async fn filter_users(
+///     QsQuery(info): QsQuery<UsersFilter>
+/// ) -> impl IntoResponse {
+///     info.id
+///         .iter()
+///         .map(|i| i.to_string())
+///         .collect::<Vec<String>>()
+///         .join(", ")
+/// }
+///
+/// fn main() {
+///     let app = Router::<()>::new()
+///         .route("/users", get(filter_users));
+/// }
+pub struct QsQuery<T>(pub T);
+
+impl<T> std::ops::Deref for QsQuery<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T: std::fmt::Display> std::fmt::Display for QsQuery<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<T: std::fmt::Debug> std::fmt::Debug for QsQuery<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+#[axum::async_trait]
+impl<T, S> FromRequestParts<S> for QsQuery<T>
+where
+    T: serde::de::DeserializeOwned,
+    S: Send + Sync,
+{
+    type Rejection = QsQueryRejection;
+
+    async fn from_request_parts(
+        parts: &mut axum::http::request::Parts,
+        state: &S,
+    ) -> Result<Self, Self::Rejection> {
+        let Extension(qs_config) = Extension::<QsQueryConfig>::from_request_parts(parts, state)
+            .await
+            .unwrap_or_else(|_| Extension(QsQueryConfig::default()));
+        let error_handler = qs_config.error_handler.clone();
+        let config: QsConfig = qs_config.into();
+        let query = parts.uri.query().unwrap_or_default();
+        match config.deserialize_str::<T>(query) {
+            Ok(value) => Ok(QsQuery(value)),
+            Err(err) => match error_handler {
+                Some(handler) => Err((handler)(err)),
+                None => Err(QsQueryRejection::new(err, StatusCode::BAD_REQUEST)),
+            },
+        }
+    }
+}
+
+#[derive(Debug)]
+/// Rejection type for extractors that deserialize query strings
+pub struct QsQueryRejection {
+    error: axum::Error,
+    status: StatusCode,
+}
+
+impl std::fmt::Display for QsQueryRejection {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Failed to deserialize query string. Error: {}",
+            self.error,
+        )
+    }
+}
+
+impl QsQueryRejection {
+    /// Create new rejection
+    pub fn new<E>(error: E, status: StatusCode) -> Self
+    where
+        E: Into<BoxError>,
+    {
+        QsQueryRejection {
+            error: Error::new(error),
+            status,
+        }
+    }
+}
+
+impl IntoResponse for QsQueryRejection {
+    fn into_response(self) -> Response {
+        let mut res = self.to_string().into_response();
+        *res.status_mut() = self.status;
+        res
+    }
+}
+
+impl std::error::Error for QsQueryRejection {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(&self.error)
+    }
+}
+
+#[derive(Clone)]
+/// Query extractor configuration
+///
+/// QsQueryConfig wraps [`Config`](crate::de::Config) and implement [`Clone`]
+/// for [`FromRequest`](https://docs.rs/axum/0.5/axum/extract/trait.FromRequest.html)
+///
+/// ## Example
+///
+/// ```rust
+/// # extern crate axum_framework as axum;
+/// use serde_qs::axum::{QsQuery, QsQueryConfig, QsQueryRejection};
+/// use serde_qs::Config;
+/// use axum::{
+///     response::IntoResponse,
+///     routing::get,
+///     Router,
+///     body::Body,
+///     extract::Extension,
+///     http::StatusCode,
+/// };
+/// use std::sync::Arc;
+///
+/// #[derive(serde::Deserialize)]
+/// pub struct UsersFilter {
+///    id: Vec<u64>,
+/// }
+///
+/// async fn filter_users(
+///     QsQuery(info): QsQuery<UsersFilter>
+/// ) -> impl IntoResponse {
+///     info.id
+///         .iter()
+///         .map(|i| i.to_string())
+///         .collect::<Vec<String>>()
+///         .join(", ")
+/// }
+///
+/// fn main() {
+///     let app = Router::<()>::new()
+///         .route("/users", get(filter_users))
+///         .layer(Extension(QsQueryConfig::new(5, false)
+///             .error_handler(|err| {
+///                 QsQueryRejection::new(err, StatusCode::UNPROCESSABLE_ENTITY)
+///         })));
+/// }
+pub struct QsQueryConfig {
+    max_depth: usize,
+    strict: bool,
+    error_handler: Option<Arc<dyn Fn(QsError) -> QsQueryRejection + Send + Sync>>,
+}
+
+impl QsQueryConfig {
+    /// Create new config wrapper
+    pub fn new(max_depth: usize, strict: bool) -> Self {
+        Self {
+            max_depth,
+            strict,
+            error_handler: None,
+        }
+    }
+
+    /// Set custom error handler
+    pub fn error_handler<F>(mut self, f: F) -> Self
+    where
+        F: Fn(QsError) -> QsQueryRejection + Send + Sync + 'static,
+    {
+        self.error_handler = Some(Arc::new(f));
+        self
+    }
+}
+
+impl From<QsQueryConfig> for QsConfig {
+    fn from(config: QsQueryConfig) -> Self {
+        Self::new(config.max_depth, config.strict)
+    }
+}
+
+impl Default for QsQueryConfig {
+    fn default() -> Self {
+        Self {
+            max_depth: 5,
+            strict: true,
+            error_handler: None,
+        }
+    }
+}