Use WithRejection Extractor to Customize Rejection Payload JSONs

api-backend/Cargo.toml

@@ -1,7 +1,6 @@
 [workspace]
 members = [
     "hartex-backend-driver",
-    "hartex-backend-extractors",
     "hartex-backend-models",
     "hartex-backend-routes",
 ]

api-backend/hartex-backend-driver/src/main.rs

@@ -77,16 +77,15 @@ pub async fn main() -> miette::Result<()> {
     let api_pgsql_url = env::var("API_PGSQL_URL").into_diagnostic()?;
 
     log::debug!("building database connection pool");
-    let manager = PostgresConnectionManager::new_from_stringlike(api_pgsql_url, NoTls).into_diagnostic()?;
+    let manager =
+        PostgresConnectionManager::new_from_stringlike(api_pgsql_url, NoTls).into_diagnostic()?;
     let pool = Pool::builder().build(manager).await.into_diagnostic()?;
 
     log::debug!("starting axum server");
     let (app, mut openapi) = OpenApiRouter::new()
         .layer(TraceLayer::new_for_http())
         .layer(TimeoutLayer::new(Duration::from_secs(30)))
-        .routes(routes!(
-            hartex_backend_routes::uptime::get_uptime
-        ))
+        .routes(routes!(hartex_backend_routes::uptime::get_uptime))
         .with_state(pool)
         .split_for_parts();
 
@@ -123,7 +122,7 @@ async fn shutdown() {
             .recv()
             .await;
     };
- 
+
     #[cfg(not(unix))]
     let terminate = future::pending::<()>();
 

api-backend/hartex-backend-models/src/lib.rs

@@ -28,19 +28,19 @@
 #![deny(unsafe_code)]
 #![deny(warnings)]
 
+use axum::http::StatusCode;
 use axum::Json;
 use serde::Deserialize;
 use serde::Serialize;
 
-pub use hartex_discord_configuration_models as config;
 pub mod uptime;
 
 /// An API response object.
 ///
 /// This is the object returned by a certain API endpoint.
 #[derive(Deserialize, Serialize)]
 pub struct Response<T> {
-    code: u16,
+    pub code: u16,
     message: String,
     data: Option<T>,
 }
@@ -49,22 +49,43 @@ impl<'a, T> Response<T>
 where
     T: Clone + Deserialize<'a>,
 {
+    #[allow(clippy::missing_panics_doc)]
+    pub fn from_code_with_data(code: StatusCode, data: T) -> (StatusCode, Json<Response<T>>) {
+        let code_display = code.to_string();
+        let part = code_display.split_once(' ').unwrap().1;
+
+        (
+            code,
+            Json(Self {
+                code: code.as_u16(),
+                message: part.to_lowercase(),
+                data: Some(data),
+            }),
+        )
+    }
+
     /// Constructs a response object with a status code of 500 and its corresponding message.
-    pub fn internal_server_error() -> Json<Response<T>> {
-        Json(Self {
-            code: 500,
-            message: String::from("internal server error"),
-            data: None,
-        })
+    pub fn internal_server_error() -> (StatusCode, Json<Response<T>>) {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(Self {
+                code: 500,
+                message: String::from("internal server error"),
+                data: None,
+            }),
+        )
     }
 
     /// Constructs a response object with a status code of 200 and its corresponding message.
-    pub fn ok(value: T) -> Json<Response<T>> {
-        Json(Self {
-            code: 200,
-            message: String::from("ok"),
-            data: Some(value),
-        })
+    pub fn ok(value: T) -> (StatusCode, Json<Response<T>>) {
+        (
+            StatusCode::OK,
+            Json(Self {
+                code: 200,
+                message: String::from("ok"),
+                data: Some(value),
+            }),
+        )
     }
 }
 

api-backend/hartex-backend-models/src/uptime.rs

@@ -24,6 +24,10 @@
 //!
 //! Models for the uptime API specification V2 of the backend.
 
+use axum::extract::rejection::QueryRejection;
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::response::Response;
 use serde::Deserialize;
 use serde::Serialize;
 use utoipa::IntoParams;
@@ -52,7 +56,27 @@ impl UptimeQuery {
     }
 }
 
-/// A response to an uptime query.
+pub struct UptimeQueryRejection {
+    status_code: StatusCode,
+    data_message: String,
+}
+
+impl From<QueryRejection> for UptimeQueryRejection {
+    fn from(value: QueryRejection) -> Self {
+        Self {
+            status_code: value.status(),
+            data_message: value.body_text().to_lowercase(),
+        }
+    }
+}
+
+impl IntoResponse for UptimeQueryRejection {
+    fn into_response(self) -> Response {
+        crate::Response::from_code_with_data(self.status_code, self.data_message).into_response()
+    }
+}
+
+/// The uptime of the specified component.
 #[allow(clippy::module_name_repetitions)]
 #[derive(Clone, Deserialize, Serialize, ToSchema)]
 pub struct UptimeResponse {
@@ -66,7 +90,7 @@ impl UptimeResponse {
         Self { start_timestamp }
     }
 
-    /// The start timestamp of the uptime entry.
+    /// The start timestamp of the uptime data.
     #[must_use]
     pub fn start_timestamp(&self) -> u128 {
         self.start_timestamp

api-backend/hartex-backend-routes/Cargo.toml

@@ -18,6 +18,7 @@ hartex_database_queries = { path = "../../database/hartex-database-queries" }
 hartex_log = { path = "../../rust-utilities/hartex-log" }
 
 axum = { version = "0.7.7", features = ["json", "macros"] }
+axum-extra = "0.9.4"
 bb8-postgres = "0.8.1"
 serde_json = "1.0.128"
 time = "0.3.36"

api-backend/hartex-backend-routes/src/uptime.rs

@@ -23,16 +23,17 @@
 /// # Uptime Routes
 ///
 /// Routes interacting with the uptime API.
-
 use axum::extract::Query;
 use axum::extract::State;
 use axum::http::StatusCode;
 use axum::Json;
+use axum_extra::extract::WithRejection;
 use bb8_postgres::bb8::Pool;
 use bb8_postgres::tokio_postgres::GenericClient;
 use bb8_postgres::tokio_postgres::NoTls;
 use bb8_postgres::PostgresConnectionManager;
 use hartex_backend_models::uptime::UptimeQuery;
+use hartex_backend_models::uptime::UptimeQueryRejection;
 use hartex_backend_models::uptime::UptimeResponse;
 use hartex_backend_models::uptime::UptimeUpdate;
 use hartex_backend_models::Response;
@@ -53,15 +54,12 @@ use time::OffsetDateTime;
 )]
 pub async fn get_uptime(
     State(pool): State<Pool<PostgresConnectionManager<NoTls>>>,
-    Query(query): Query<UptimeQuery>,
+    WithRejection(Query(query), _): WithRejection<Query<UptimeQuery>, UptimeQueryRejection>,
 ) -> (StatusCode, Json<Response<UptimeResponse>>) {
     log::trace!("retrieving connection from database pool");
     let result = pool.get().await;
     if result.is_err() {
-        return (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            Response::internal_server_error(),
-        );
+        return Response::internal_server_error();
     }
 
     let connection = result.unwrap();
@@ -77,19 +75,13 @@ pub async fn get_uptime(
     if result.is_err() {
         log::error!("{:?}", result.unwrap_err());
 
-        return (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            Response::internal_server_error(),
-        );
+        return Response::internal_server_error();
     }
     let data = result.unwrap();
 
-    (
-        StatusCode::OK,
-        Response::ok(UptimeResponse::with_start_timestamp(
-            data.timestamp.unix_timestamp() as u128,
-        )),
-    )
+    Response::ok(UptimeResponse::with_start_timestamp(
+        data.timestamp.unix_timestamp() as u128,
+    ))
 }
 
 /// # `PATCH /stats/uptime`
@@ -106,10 +98,7 @@ pub async fn patch_uptime(
     log::trace!("retrieving connection from database pool");
     let result = pool.get().await;
     if result.is_err() {
-        return (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            Response::internal_server_error(),
-        );
+        return Response::internal_server_error();
     }
 
     let connection = result.unwrap();
@@ -119,24 +108,15 @@ pub async fn patch_uptime(
     let Ok(timestamp) = OffsetDateTime::from_unix_timestamp(query.start_timestamp() as i64) else {
         // FIXME: return a better status code as the timestamp is out of range if this branch is reached
         // just 500 for now
-        return (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            Response::internal_server_error(),
-        );
+        return Response::internal_server_error();
     };
     let result = start_timestamp_upsert()
         .bind(client, &query.component_name(), &timestamp)
         .await;
 
     if result.is_err() {
-        return (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            Response::internal_server_error(),
-        );
+        return Response::internal_server_error();
     }
 
-    (
-        StatusCode::OK,
-        Response::ok(()),
-    )
+    Response::ok(())
 }