sync up relevant changes from axum

GlenDC · svix-jplatte · GlenDC · commit ce2b60e65da4 · 2025-04-23T18:28:53.000+02:00
Only applicable and interesting to us was: <tokio-rs/axum@af6a595> Co-authored-by: Jonas Platte <jplatte@svix.com>
diff --git a/FORK.md b/FORK.md
@@ -25,8 +25,7 @@ as a distant relative.
     <https://github.com/plabayo/tower-async/tree/57798b7baea8e212197a226a2481fa282591dda4>
 
 ## Relative Forks
-
-- <https://github.com/tokio-rs/axum/tree/2b6ae09568f29451b731674a578275955314badc>
+- <https://github.com/tokio-rs/axum/tree/9c9cbb5c5f72452825388d63db4f1e36c0d9b3aa>
   - IntoResponse Code
   - (Optional)FromRequest/ (Optional)FromRequestParts code
   - Error/BoxError
diff --git a/docs/index.html b/docs/index.html
@@ -85,7 +85,7 @@ <h2>Built for Modularity</h2>
         <section class="installation-section">
             <h2>Get Started with Rama</h2>
             <p>
-                Choose your preferred installation method: add Rama as a
+                Choose your preferred installation method. Either add Rama as a
                 framework dependency to your Rust project for maximum flexibility and control,
                 or install the pre-built Rama CLI binary for immediate use as
                 a standalone tool without writing code:
@@ -128,7 +128,7 @@ <h2>Get Started with Rama</h2>
 
             <div class="installation-links">
                 <a href="https://ramaproxy.org/book/deploy/rama-cli.html">Alternative Installation Methods</a>
-                <a href="https://docs.rs/rama">API Documentation</a>
+                <a href="https://docs.rs/rama">Rust Documentation</a>
                 <a href="https://github.com/plabayo/rama">Source Code</a>
             </div>
         </section>
@@ -671,4 +671,4 @@ <h2>Supported by</h2>
     </footer>
 </body>
 
-</html>
+</html>
diff --git a/rama-http-types/src/response/csv.rs b/rama-http-types/src/response/csv.rs
@@ -1,5 +1,6 @@
 use crate::response::{IntoResponse, Response};
 use crate::{Body, dep::http::StatusCode};
+use bytes::buf::Writer;
 use bytes::{BufMut, BytesMut};
 use csv;
 use headers::ContentType;
@@ -87,12 +88,11 @@ where
     T: IntoIterator<Item: Serialize> + std::fmt::Debug,
 {
     fn into_response(self) -> Response {
-        // Use a small initial capacity of 128 bytes like serde_json::to_vec
-        // https://docs.rs/serde_json/1.0.82/src/serde_json/ser.rs.html#2189
-        let mut buf = BytesMut::with_capacity(128).writer();
-        {
-            let mut wtr = csv::Writer::from_writer(&mut buf);
-            let res: Result<Vec<_>, _> = self.0.into_iter().map(|rec| wtr.serialize(rec)).collect();
+        // Extracted into separate fn so it's only compiled once for all T.
+        fn make_respone(
+            res: csv::Result<Vec<()>>,
+            mut wtr: csv::Writer<Writer<BytesMut>>,
+        ) -> Response {
             if let Err(err) = res {
                 return (
                     StatusCode::INTERNAL_SERVER_ERROR,
@@ -109,13 +109,34 @@ where
                 )
                     .into_response();
             }
+
+            let bw = match wtr.into_inner() {
+                Ok(bw) => bw,
+                Err(err) => {
+                    return (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        Headers::single(ContentType::text_utf8()),
+                        err.to_string(),
+                    )
+                        .into_response();
+                }
+            };
+
+            (
+                [(CONTENT_TYPE, HeaderValue::from_static("text/csv"))],
+                bw.into_inner().freeze(),
+            )
+                .into_response()
         }
 
-        (
-            [(CONTENT_TYPE, HeaderValue::from_static("text/csv"))],
-            buf.into_inner().freeze(),
-        )
-            .into_response()
+        // Use a small initial capacity of 128 bytes like serde_json::to_vec
+        // https://docs.rs/serde_json/1.0.82/src/serde_json/ser.rs.html#2189
+        let buf = BytesMut::with_capacity(128).writer();
+
+        let mut wtr = csv::Writer::from_writer(buf);
+        let res: Result<Vec<_>, _> = self.0.into_iter().map(|rec| wtr.serialize(rec)).collect();
+
+        make_respone(res, wtr)
     }
 }
 
diff --git a/rama-http-types/src/response/form.rs b/rama-http-types/src/response/form.rs
@@ -89,13 +89,19 @@ where
     T: Serialize,
 {
     fn into_response(self) -> Response {
-        match serde_html_form::to_string(&self.0) {
-            Ok(body) => (Headers::single(ContentType::form_url_encoded()), body).into_response(),
-            Err(err) => {
-                tracing::error!(error = %err, "response error");
-                StatusCode::INTERNAL_SERVER_ERROR.into_response()
+        // Extracted into separate fn so it's only compiled once for all T.
+        fn make_response(ser_result: Result<String, serde_html_form::ser::Error>) -> Response {
+            match ser_result {
+                Ok(body) => {
+                    (Headers::single(ContentType::form_url_encoded()), body).into_response()
+                }
+                Err(err) => {
+                    tracing::error!(error = %err, "response error");
+                    StatusCode::INTERNAL_SERVER_ERROR.into_response()
+                }
             }
         }
+        make_response(serde_html_form::to_string(&self.0))
     }
 }
 
diff --git a/rama-http-types/src/response/json.rs b/rama-http-types/src/response/json.rs
@@ -80,22 +80,23 @@ where
     T: Serialize,
 {
     fn into_response(self) -> Response {
+        // Extracted into separate fn so it's only compiled once for all T.
+        fn make_respone(buf: BytesMut, ser_result: serde_json::Result<()>) -> Response {
+            match ser_result {
+                Ok(()) => (Headers::single(ContentType::json()), buf.freeze()).into_response(),
+                Err(err) => (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Headers::single(ContentType::text_utf8()),
+                    err.to_string(),
+                )
+                    .into_response(),
+            }
+        }
         // Use a small initial capacity of 128 bytes like serde_json::to_vec
         // https://docs.rs/serde_json/1.0.82/src/serde_json/ser.rs.html#2189
         let mut buf = BytesMut::with_capacity(128).writer();
-        match serde_json::to_writer(&mut buf, &self.0) {
-            Ok(()) => (
-                Headers::single(ContentType::json()),
-                buf.into_inner().freeze(),
-            )
-                .into_response(),
-            Err(err) => (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Headers::single(ContentType::text_utf8()),
-                err.to_string(),
-            )
-                .into_response(),
-        }
+        let res = serde_json::to_writer(&mut buf, &self.0);
+        make_respone(buf.into_inner(), res)
     }
 }
 
diff --git a/rama-http/src/service/web/endpoint/extract/body/csv.rs b/rama-http/src/service/web/endpoint/extract/body/csv.rs
@@ -3,7 +3,7 @@ use crate::Request;
 use crate::dep::http_body_util::BodyExt;
 use crate::service::web::extract::FromRequest;
 use crate::utils::macros::{composite_http_rejection, define_http_rejection};
-use bytes::Buf;
+use bytes::{Buf, Bytes};
 
 pub use crate::response::Csv;
 
@@ -43,30 +43,35 @@ where
     type Rejection = CsvRejection;
 
     async fn from_request(req: Request) -> Result<Self, Self::Rejection> {
-        if !crate::service::web::extract::has_any_content_type(req.headers(), &[&mime::TEXT_CSV]) {
-            return Err(InvalidCsvContentType.into());
+        // Extracted into separate fn so it's only compiled once for all T.
+        async fn req_to_csv_bytes(req: Request) -> Result<Bytes, CsvRejection> {
+            if !crate::service::web::extract::has_any_content_type(
+                req.headers(),
+                &[&mime::TEXT_CSV],
+            ) {
+                return Err(InvalidCsvContentType.into());
+            }
+
+            let body = req.into_body();
+            let bytes = body.collect().await.map_err(BytesRejection::from_err)?;
+
+            Ok(bytes.to_bytes())
         }
 
-        let body = req.into_body();
-        match body.collect().await {
-            Ok(c) => {
-                let b = c.to_bytes();
-                let mut rdr = csv::Reader::from_reader(b.clone().reader());
-
-                let out: Result<Vec<T>, _> = rdr
-                    .deserialize()
-                    .map(|rec| {
-                        let record: Result<T, _> = rec;
-                        record
-                    })
-                    .collect();
-
-                match out {
-                    Ok(s) => Ok(Self(s)),
-                    Err(err) => Err(FailedToDeserializeCsv::from_err(err).into()),
-                }
-            }
-            Err(err) => Err(BytesRejection::from_err(err).into()),
+        let b = req_to_csv_bytes(req).await?;
+        let mut rdr = csv::Reader::from_reader(b.reader());
+
+        let out: Result<Vec<T>, _> = rdr
+            .deserialize()
+            .map(|rec| {
+                let record: Result<T, _> = rec;
+                record
+            })
+            .collect();
+
+        match out {
+            Ok(s) => Ok(Self(s)),
+            Err(err) => Err(FailedToDeserializeCsv::from_err(err).into()),
         }
     }
 }
diff --git a/rama-http/src/service/web/endpoint/extract/body/form.rs b/rama-http/src/service/web/endpoint/extract/body/form.rs
@@ -1,3 +1,5 @@
+use bytes::Bytes;
+
 use super::BytesRejection;
 use crate::dep::http_body_util::BodyExt;
 use crate::service::web::extract::FromRequest;
@@ -42,14 +44,8 @@ where
     type Rejection = FormRejection;
 
     async fn from_request(req: Request) -> Result<Self, Self::Rejection> {
-        if req.method() == Method::GET {
-            let query = req.uri().query().unwrap_or_default();
-            let value = match serde_html_form::from_bytes(query.as_bytes()) {
-                Ok(value) => value,
-                Err(err) => return Err(FailedToDeserializeForm::from_err(err).into()),
-            };
-            Ok(Form(value))
-        } else {
+        // Extracted into separate fn so it's only compiled once for all T.
+        async fn extract_form_body_bytes(req: Request) -> Result<Bytes, FormRejection> {
             if !crate::service::web::extract::has_any_content_type(
                 req.headers(),
                 &[&mime::APPLICATION_WWW_FORM_URLENCODED],
@@ -58,16 +54,24 @@ where
             }
 
             let body = req.into_body();
-            match body.collect().await {
-                Ok(c) => {
-                    let value = match serde_html_form::from_bytes(&c.to_bytes()) {
-                        Ok(value) => value,
-                        Err(err) => return Err(FailedToDeserializeForm::from_err(err).into()),
-                    };
-                    Ok(Form(value))
-                }
-                Err(err) => Err(BytesRejection::from_err(err).into()),
-            }
+            let bytes = body.collect().await.map_err(BytesRejection::from_err)?;
+
+            Ok(bytes.to_bytes())
+        }
+
+        if req.method() == Method::GET {
+            let query = req.uri().query().unwrap_or_default();
+            let value = match serde_html_form::from_bytes(query.as_bytes()) {
+                Ok(value) => value,
+                Err(err) => return Err(FailedToDeserializeForm::from_err(err).into()),
+            };
+            Ok(Form(value))
+        } else {
+            let b = extract_form_body_bytes(req).await?;
+            Ok(Form(match serde_html_form::from_bytes(&b) {
+                Ok(value) => value,
+                Err(err) => return Err(FailedToDeserializeForm::from_err(err).into()),
+            }))
         }
     }
 }
diff --git a/rama-http/src/service/web/endpoint/extract/body/json.rs b/rama-http/src/service/web/endpoint/extract/body/json.rs
@@ -1,3 +1,5 @@
+use bytes::Bytes;
+
 use super::BytesRejection;
 use crate::Request;
 use crate::dep::http_body_util::BodyExt;
@@ -42,23 +44,27 @@ where
     type Rejection = JsonRejection;
 
     async fn from_request(req: Request) -> Result<Self, Self::Rejection> {
-        if !crate::service::web::extract::has_any_content_type(
-            req.headers(),
-            &[&mime::APPLICATION_JSON],
-        ) {
-            return Err(InvalidJsonContentType.into());
-        }
+        // Extracted into separate fn so it's only compiled once for all T.
+        async fn extract_json_bytes(req: Request) -> Result<Bytes, JsonRejection> {
+            if !crate::service::web::extract::has_any_content_type(
+                req.headers(),
+                &[&mime::APPLICATION_JSON],
+            ) {
+                return Err(InvalidJsonContentType.into());
+            }
 
-        let body = req.into_body();
-        match body.collect().await {
-            Ok(c) => {
-                let b = c.to_bytes();
-                match serde_json::from_slice(&b) {
-                    Ok(s) => Ok(Self(s)),
-                    Err(err) => Err(FailedToDeserializeJson::from_err(err).into()),
-                }
+            let body = req.into_body();
+
+            match body.collect().await {
+                Ok(c) => Ok(c.to_bytes()),
+                Err(err) => Err(BytesRejection::from_err(err).into()),
             }
-            Err(err) => Err(BytesRejection::from_err(err).into()),
+        }
+
+        let b = extract_json_bytes(req).await?;
+        match serde_json::from_slice(&b) {
+            Ok(s) => Ok(Self(s)),
+            Err(err) => Err(FailedToDeserializeJson::from_err(err).into()),
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -89,13 +89,19 @@ where`
`89`	`89`	`T: Serialize,`
`90`	`90`	`{`
`91`	`91`	`fn into_response(self) -> Response {`
`92`		`- match serde_html_form::to_string(&self.0) {`
`93`		`- Ok(body) => (Headers::single(ContentType::form_url_encoded()), body).into_response(),`
`94`		`- Err(err) => {`
`95`		`- tracing::error!(error = %err, "response error");`
`96`		`- StatusCode::INTERNAL_SERVER_ERROR.into_response()`
	`92`	`+ // Extracted into separate fn so it's only compiled once for all T.`
	`93`	`+ fn make_response(ser_result: Result<String, serde_html_form::ser::Error>) -> Response {`
	`94`	`+ match ser_result {`
	`95`	`+ Ok(body) => {`
	`96`	`+ (Headers::single(ContentType::form_url_encoded()), body).into_response()`
	`97`	`+ }`
	`98`	`+ Err(err) => {`
	`99`	`+ tracing::error!(error = %err, "response error");`
	`100`	`+ StatusCode::INTERNAL_SERVER_ERROR.into_response()`
	`101`	`+ }`
`97`	`102`	`}`
`98`	`103`	`}`
	`104`	`+ make_response(serde_html_form::to_string(&self.0))`
`99`	`105`	`}`
`100`	`106`	`}`
`101`	`107`