Add adapter for Axum -> Vercel

Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "crates/vercel_runtime",
     "crates/vercel_runtime_macro",
     "crates/vercel_runtime_router",
+    "crates/vercel_axum",
     "examples/cron",
     "examples/nextjs",
     "examples/simple",

crates/vercel_axum/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "vercel_axum"
+version = "1.1.3"
+edition = "2021"
+authors = ["Vercel <support@vercel.com>"]
+description = "Vercel Rust Axum Adapter"
+keywords = ["Vercel", "Rust", "Serverless", "Functions", "Axum"]
+license = "MIT"
+homepage = "https://github.com/vercel-community/rust"
+repository = "https://github.com/vercel-community/rust"
+documentation = "https://docs.rs/vercel_lambda"
+include = ["src/*.rs", "Cargo.toml"]
+exclude = ["tests/*"]
+
+[dependencies]
+axum = "0.7"
+base64 = "0.22"
+http-body-util = "0.1"
+tower = "0.4"
+tower-service = "0.3"
+serde_json = "1.0"
+vercel_runtime = "1.1.3"
+# vercel_runtime = { version = "1.1.3", path = "../vercel_runtime" }

crates/vercel_axum/src/lib.rs

@@ -0,0 +1,90 @@
+use axum::response::IntoResponse;
+use base64::prelude::*;
+use http_body_util::BodyExt;
+use std::{future::Future, pin::Pin};
+use tower::Layer;
+use tower_service::Service;
+
+use vercel_runtime::request::{Event, VercelRequest};
+use vercel_runtime::response::EventResponse;
+
+#[derive(Clone, Copy)]
+pub struct VercelLayer;
+
+impl<S> Layer<S> for VercelLayer {
+    type Service = VercelService<S>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        VercelService { inner }
+    }
+}
+
+pub struct VercelService<S> {
+    inner: S,
+}
+
+impl<S> Service<Event<'_>> for VercelService<S>
+where
+    S: Service<axum::http::Request<axum::body::Body>>,
+    S::Response: axum::response::IntoResponse + Send + 'static,
+    S::Error: std::error::Error + Send + Sync + 'static,
+    S::Future: Send + 'static,
+{
+    type Response = EventResponse;
+    type Error = vercel_runtime::Error;
+    type Future =
+        Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send + 'static>>;
+
+    fn poll_ready(
+        &mut self,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx).map_err(Into::into)
+    }
+
+    fn call(&mut self, event: Event) -> Self::Future {
+        let (event, _context) = event.into_parts();
+        let request = serde_json::from_str::<VercelRequest>(&event.body).unwrap_or_default();
+
+        let mut builder = axum::http::request::Builder::new()
+            .method(request.method)
+            .uri(format!("https://{}{}", request.host, request.path));
+        for (key, value) in request.headers {
+            if let Some(k) = key {
+                builder = builder.header(k, value);
+            }
+        }
+
+        let request: axum::http::Request<axum::body::Body> = match (request.body, request.encoding)
+        {
+            (Some(b), Some(encoding)) if encoding == "base64" => {
+                let engine = base64::prelude::BASE64_STANDARD;
+                let body = axum::body::Body::from(engine.decode(b.as_ref()).unwrap_or_default());
+                builder.body(body).unwrap_or_default()
+            }
+            (Some(b), _) => builder.body(axum::body::Body::from(b)).unwrap_or_default(),
+            (None, _) => builder.body(axum::body::Body::default()).unwrap_or_default(),
+        };
+
+        let fut = self.inner.call(request);
+        let fut = async move {
+            let resp = fut.await?;
+            let (parts, body) = resp.into_response().into_parts();
+            let bytes = body.into_data_stream().collect().await?.to_bytes();
+            let bytes: &[u8] = &bytes;
+            let body = std::str::from_utf8(bytes).unwrap_or_default();
+            let body: Option<vercel_runtime::Body> = match body {
+                "" => None,
+                _ => Some(body.into()),
+            };
+            Ok(EventResponse {
+                status_code: parts.status.as_u16(),
+                body,
+                headers: parts.headers,
+                encoding: None,
+            })
+        };
+
+        Box::pin(fut)
+    }
+}

crates/vercel_runtime/Cargo.toml

@@ -26,6 +26,7 @@ serde = { version = "1.0.188", features = ["derive"] }
 serde_json = { version = "1.0.106", features = ["raw_value"] }
 tower-http = { version = "0.5", features = ["cors"] }
 tower-service = "0.3.2"
+http-serde = "2.1.1"
 base64 = "0.22"
 bytes = "1.5.0"
 async-trait = "0.1.73"

crates/vercel_runtime/src/response.rs

@@ -3,7 +3,6 @@ use lambda_http::http::{
     Response,
 };
 use lambda_http::Body;
-use serde::ser::{Error as SerError, SerializeMap, Serializer};
 use serde::Serialize;
 
 #[derive(Serialize, Debug)]
@@ -12,7 +11,7 @@ pub struct EventResponse {
     pub status_code: u16,
     #[serde(
         skip_serializing_if = "HeaderMap::is_empty",
-        serialize_with = "serialize_headers"
+        with = "http_serde::header_map"
     )]
     pub headers: HeaderMap<HeaderValue>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -32,18 +31,6 @@ impl Default for EventResponse {
     }
 }
 
-fn serialize_headers<S>(headers: &HeaderMap<HeaderValue>, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    let mut map = serializer.serialize_map(Some(headers.keys_len()))?;
-    for key in headers.keys() {
-        let map_value = headers[key].to_str().map_err(S::Error::custom)?;
-        map.serialize_entry(key.as_str(), map_value)?;
-    }
-    map.end()
-}
-
 impl<T> From<Response<T>> for EventResponse
 where
     T: Into<Body>,