fix(api): revert axum upgrade (#1021)

Revert axum upgrade

Cargo.toml

@@ -56,7 +56,7 @@ influxdb = { version = "0.5", default-features = false, features = [ "use-serde"
 
 # API
 auth-helper = { version = "0.3", default-features = false, optional = true }
-axum = { version = "0.6", default-features = false, features = [ "http1", "json", "query", "original-uri", "headers" ], optional = true }
+axum = { version = "0.5", default-features = false, features = [ "http1", "json", "query", "original-uri", "headers" ], optional = true }
 ed25519 = { version = "1.5", default-features = false, features = [ "alloc", "pkcs8", "pem" ], optional = true }
 ed25519-dalek = { version = "1.0", default-features = false, features = [ "u64_backend" ], optional = true }
 hex = { version = "0.4", default-features = false, optional = true }

src/bin/inx-chronicle/api/auth.rs

@@ -4,33 +4,30 @@
 use async_trait::async_trait;
 use auth_helper::jwt::{BuildValidation, JsonWebToken, Validation};
 use axum::{
-    extract::{FromRef, FromRequestParts, OriginalUri},
+    extract::{FromRequest, OriginalUri},
     headers::{authorization::Bearer, Authorization},
-    TypedHeader,
+    Extension, TypedHeader,
 };
 
 use super::{config::ApiConfigData, error::RequestError, ApiError, AuthError};
 
 pub struct Auth;
 
 #[async_trait]
-impl<S: Send + Sync> FromRequestParts<S> for Auth
-where
-    ApiConfigData: FromRef<S>,
-{
+impl<B: Send> FromRequest<B> for Auth {
     type Rejection = ApiError;
 
-    async fn from_request_parts(req: &mut axum::http::request::Parts, state: &S) -> Result<Self, Self::Rejection> {
+    async fn from_request(req: &mut axum::extract::RequestParts<B>) -> Result<Self, Self::Rejection> {
         // Unwrap: <OriginalUri as FromRequest>::Rejection = Infallable
-        let OriginalUri(uri) = OriginalUri::from_request_parts(req, state).await.unwrap();
+        let OriginalUri(uri) = OriginalUri::from_request(req).await.unwrap();
 
-        let config = ApiConfigData::from_ref(state);
+        let Extension(config) = Extension::<ApiConfigData>::from_request(req).await?;
 
         if config.public_routes.is_match(&uri.to_string()) {
             return Ok(Auth);
         }
 
-        let TypedHeader(Authorization(bearer)) = TypedHeader::<Authorization<Bearer>>::from_request_parts(req, state)
+        let TypedHeader(Authorization(bearer)) = TypedHeader::<Authorization<Bearer>>::from_request(req)
             .await
             .map_err(RequestError::from)?;
         let jwt = JsonWebToken(bearer.token().to_string());

src/bin/inx-chronicle/api/extractors.rs

@@ -2,7 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use async_trait::async_trait;
-use axum::extract::{FromRef, FromRequestParts, Query};
+use axum::{
+    extract::{FromRequest, Query},
+    Extension,
+};
 use serde::Deserialize;
 
 use super::{
@@ -28,17 +31,14 @@ impl Default for Pagination {
 }
 
 #[async_trait]
-impl<S: Send + Sync> FromRequestParts<S> for Pagination
-where
-    ApiConfigData: FromRef<S>,
-{
+impl<B: Send> FromRequest<B> for Pagination {
     type Rejection = ApiError;
 
-    async fn from_request_parts(req: &mut axum::http::request::Parts, state: &S) -> Result<Self, Self::Rejection> {
-        let Query(mut pagination) = Query::<Pagination>::from_request_parts(req, state)
+    async fn from_request(req: &mut axum::extract::RequestParts<B>) -> Result<Self, Self::Rejection> {
+        let Query(mut pagination) = Query::<Pagination>::from_request(req)
             .await
             .map_err(RequestError::from)?;
-        let config = ApiConfigData::from_ref(state);
+        let Extension(config) = Extension::<ApiConfigData>::from_request(req).await?;
         pagination.page_size = pagination.page_size.min(config.max_page_size);
         Ok(pagination)
     }
@@ -51,11 +51,11 @@ pub struct ListRoutesQuery {
 }
 
 #[async_trait]
-impl<S: Send + Sync> FromRequestParts<S> for ListRoutesQuery {
+impl<B: Send> FromRequest<B> for ListRoutesQuery {
     type Rejection = ApiError;
 
-    async fn from_request_parts(req: &mut axum::http::request::Parts, state: &S) -> Result<Self, Self::Rejection> {
-        let Query(query) = Query::<ListRoutesQuery>::from_request_parts(req, state)
+    async fn from_request(req: &mut axum::extract::RequestParts<B>) -> Result<Self, Self::Rejection> {
+        let Query(query) = Query::<ListRoutesQuery>::from_request(req)
             .await
             .map_err(RequestError::from)?;
         Ok(query)
@@ -83,14 +83,14 @@ mod stardust {
     }
 
     #[async_trait]
-    impl<S: Send + Sync> FromRequestParts<S> for TimeRange {
+    impl<B: Send> FromRequest<B> for TimeRange {
         type Rejection = ApiError;
 
-        async fn from_request_parts(req: &mut axum::http::request::Parts, state: &S) -> Result<Self, Self::Rejection> {
+        async fn from_request(req: &mut axum::extract::RequestParts<B>) -> Result<Self, Self::Rejection> {
             let Query(TimeRangeQuery {
                 start_timestamp,
                 end_timestamp,
-            }) = Query::<TimeRangeQuery>::from_request_parts(req, state)
+            }) = Query::<TimeRangeQuery>::from_request(req)
                 .await
                 .map_err(RequestError::from)?;
             if matches!((start_timestamp, end_timestamp), (Some(start), Some(end)) if end < start) {
@@ -110,25 +110,26 @@ pub use stardust::*;
 
 #[cfg(test)]
 mod test {
-    use axum::{extract::FromRequest, http::Request};
+    use axum::{
+        extract::{FromRequest, RequestParts},
+        http::Request,
+    };
 
     use super::*;
     use crate::api::ApiConfig;
 
     #[tokio::test]
     async fn page_size_clamped() {
-        let config = ApiConfig {
-            max_page_size: 1000,
-            ..Default::default()
-        };
-        let data = ApiConfigData::try_from(config).unwrap();
-        let req = Request::builder()
-            .method("GET")
-            .uri("/?pageSize=9999999")
-            .body(())
-            .unwrap();
+        let mut req = RequestParts::new(
+            Request::builder()
+                .method("GET")
+                .uri("/?pageSize=9999999")
+                .extension(ApiConfigData::try_from(ApiConfig::default()).unwrap())
+                .body(())
+                .unwrap(),
+        );
         assert_eq!(
-            Pagination::from_request(req, &data).await.unwrap(),
+            Pagination::from_request(&mut req).await.unwrap(),
             Pagination {
                 page_size: 1000,
                 ..Default::default()

src/bin/inx-chronicle/api/mod.rs

@@ -18,9 +18,10 @@ pub mod config;
 mod router;
 mod routes;
 
+use axum::{Extension, Server};
 use chronicle::db::MongoDb;
 use futures::Future;
-use hyper::{Method, Server};
+use hyper::Method;
 use tower_http::{
     catch_panic::CatchPanicLayer,
     cors::{Any, CorsLayer},
@@ -38,7 +39,7 @@ pub use self::{
 pub const DEFAULT_PAGE_SIZE: usize = 100;
 
 /// The Chronicle API actor
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ApiWorker {
     db: MongoDb,
     api_data: ApiConfigData,
@@ -57,8 +58,9 @@ impl ApiWorker {
         info!("Starting API server on port `{}`", self.api_data.port);
 
         let port = self.api_data.port;
-        let routes = routes(self.api_data.clone())
-            .with_state(self.clone())
+        let routes = routes()
+            .layer(Extension(self.db.clone()))
+            .layer(Extension(self.api_data.clone()))
             .layer(CatchPanicLayer::new())
             .layer(TraceLayer::new_for_http())
             .layer(