Change impl IntoResponse into Response<Body> (#1)

dglsparsons · ecklf · web-flow · commit b1a8b873d7d4 · 2023-03-07T10:28:02.000+01:00
* Rework to allow merging api endpoints

* Rework all examples and simplify structure

* remove `IntoResponse`

---------

Co-authored-by: Florentin / 珞辰 &lt;ecklf@icloud.com&gt;
diff --git a/examples/cron/Cargo.lock b/examples/cron/Cargo.lock
diff --git a/examples/cron/Cargo.toml b/examples/cron/Cargo.toml
@@ -12,7 +12,7 @@ serde = { version = "1.0.145", features = ["derive"] }
 serde_json = { version = "1.0.86", features = ["raw_value"] }
 serde_derive = "1.0.9"
 rand = "0.8.5"
-vercel_runtime = "0.1.4"
+vercel_runtime = { version = "0.1.4", path = "../../vercel_runtime" }
 slack-morphism = { version = "1.2.2", features = ["hyper"] }
 
 [[bin]]
diff --git a/examples/cron/api/cron.rs b/examples/cron/api/cron.rs
@@ -1,8 +1,5 @@
 use slack_morphism::{errors::SlackClientError, prelude::*};
-use vercel_runtime::{
-    lambda_http::{http::StatusCode, Response},
-    run, Error, IntoResponse, Request,
-};
+use vercel_runtime::{run, Body, Error, Request, Response, StatusCode};
 
 #[derive(Debug, Clone)]
 pub struct SlackMessage {}
@@ -31,12 +28,12 @@ impl<T: SlackClientHttpConnector + Send + Sync> Lambda<'_, T> {
         self.slack.chat_post_message(&post_chat_req).await
     }
 
-    pub async fn handler(&self, _req: Request) -> Result<impl IntoResponse, Error> {
+    pub async fn handler(&self, _req: Request) -> Result<Response<Body>, Error> {
         let message = SlackMessage {};
 
         self.post_message(&message, "#general").await?;
 
-        let response = Response::builder().status(StatusCode::OK).body(())?;
+        let response = Response::builder().status(StatusCode::OK).body(().into())?;
         Ok(response)
     }
 }
diff --git a/examples/merged/Cargo.lock b/examples/merged/Cargo.lock
diff --git a/examples/merged/Cargo.toml b/examples/merged/Cargo.toml
@@ -11,7 +11,7 @@ serde = { version = "1.0.145", features = ["derive"] }
 serde_json = { version = "1.0.86", features = ["raw_value"] }
 serde_derive = "1.0.9"
 rand = "0.8.5"
-vercel_runtime = "0.1.4"
+vercel_runtime = { version = "0.1.4", path = "../../vercel_runtime" }
 url = "2.3.1"
 
 [lib]
diff --git a/examples/merged/api/bar/baz.rs b/examples/merged/api/bar/baz.rs
@@ -1,11 +1,8 @@
 use runtime_demo::choose_starter;
 use serde_json::json;
-use vercel_runtime::{
-    lambda_http::{http::StatusCode, Response},
-    Error, IntoResponse, Request,
-};
+use vercel_runtime::{Body, Error, Request, Response, StatusCode};
 
-pub async fn handler(_req: Request) -> Result<impl IntoResponse, Error> {
+pub async fn handler(_req: Request) -> Result<Response<Body>, Error> {
     dbg!(_req);
     let starter = choose_starter();
     let response = Response::builder()
@@ -15,7 +12,8 @@ pub async fn handler(_req: Request) -> Result<impl IntoResponse, Error> {
             json!({
               "message": format!("I choose you, {}!", starter),
             })
-            .to_string(),
+            .to_string()
+            .into(),
         )?;
 
     Ok(response)
diff --git a/examples/merged/api/foo.rs b/examples/merged/api/foo.rs
@@ -1,11 +1,8 @@
 use runtime_demo::choose_starter;
 use serde_json::json;
-use vercel_runtime::{
-    lambda_http::{http::StatusCode, Response},
-    Error, IntoResponse, Request,
-};
+use vercel_runtime::{Body, Error, Request, Response, StatusCode};
 
-pub async fn handler(_req: Request) -> Result<impl IntoResponse, Error> {
+pub async fn handler(_req: Request) -> Result<Response<Body>, Error> {
     dbg!(_req);
     let starter = choose_starter();
     let response = Response::builder()
@@ -15,7 +12,8 @@ pub async fn handler(_req: Request) -> Result<impl IntoResponse, Error> {
             json!({
               "message": format!("I choose you, {}!", starter),
             })
-            .to_string(),
+            .to_string()
+            .into(),
         )?;
 
     Ok(response)
diff --git a/examples/merged/api/index.rs b/examples/merged/api/index.rs
@@ -1,12 +1,12 @@
-use vercel_runtime::{run, Error, IntoResponse, Request};
+use vercel_runtime::{run, Body, Error, Request, Response};
 
 #[path = "../api/bar/baz.rs"]
 mod api_bar_baz;
 
 #[path = "../api/foo.rs"]
 mod api_foo;
 
-async fn process_request(request: Request) -> Result<impl IntoResponse, Error> {
+async fn process_request(request: Request) -> Result<Response<Body>, Error> {
     let path = request.uri().path();
 
     match path {
diff --git a/examples/nextjs/Cargo.lock b/examples/nextjs/Cargo.lock
diff --git a/examples/nextjs/Cargo.toml b/examples/nextjs/Cargo.toml
@@ -12,7 +12,7 @@ serde = { version = "1.0.145", features = ["derive"] }
 serde_json = { version = "1.0.86", features = ["raw_value"] }
 serde_derive = "1.0.9"
 rand = "0.8.5"
-vercel_runtime = "0.1.4"
+vercel_runtime = { version = "0.1.4", path = "../../vercel_runtime" }
 oorandom = "11.1.3"
 
 [[bin]]
diff --git a/examples/nextjs/api/rust.rs b/examples/nextjs/api/rust.rs
@@ -1,16 +1,13 @@
 use serde_json::json;
 use std::time::Instant;
-use vercel_runtime::{
-    lambda_http::{http::StatusCode, Error as LambdaError, Response},
-    run, Error, IntoResponse, Request,
-};
+use vercel_runtime::{run, Body, Error, Request, Response, StatusCode};
 
 #[tokio::main]
-async fn main() -> Result<(), LambdaError> {
+async fn main() -> Result<(), Error> {
     run(handler).await
 }
 
-pub async fn handler(_req: Request) -> Result<impl IntoResponse, Error> {
+pub async fn handler(_req: Request) -> Result<Response<Body>, Error> {
     let start = Instant::now();
 
     let seed = 42;
@@ -44,7 +41,7 @@ pub async fn handler(_req: Request) -> Result<impl IntoResponse, Error> {
                 "time": format!("{:.2?}", duration),
                 "pi": pi
             })
-            .to_string(),
+            .into(),
         )?;
 
     Ok(response)
diff --git a/examples/simple/Cargo.lock b/examples/simple/Cargo.lock
diff --git a/examples/simple/Cargo.toml b/examples/simple/Cargo.toml
@@ -11,7 +11,7 @@ serde = { version = "1.0.145", features = ["derive"] }
 serde_json = { version = "1.0.86", features = ["raw_value"] }
 serde_derive = "1.0.9"
 rand = "0.8.5"
-vercel_runtime = "0.1.4"
+vercel_runtime = { version = "0.1.4", path = "../../vercel_runtime" }
 
 [lib]
 path = "src-rs/lib.rs"
diff --git a/examples/simple/api/complex.rs b/examples/simple/api/complex.rs
@@ -1,8 +1,8 @@
 use runtime_demo::choose_starter;
 use serde_json::json;
 use vercel_runtime::{
-    lambda_http::{http::StatusCode, service_fn, tower::ServiceBuilder, Response},
-    lambda_runtime, process_request, process_response, Error, IntoResponse, Request,
+    process_request, process_response, run_service, service_fn, Body, Error, Request, Response,
+    ServiceBuilder, StatusCode,
 };
 
 #[tokio::main]
@@ -19,10 +19,10 @@ async fn main() -> Result<(), Error> {
         .map_response(process_response)
         .service(service_fn(handler));
 
-    lambda_runtime::run(handler).await
+    run_service(handler).await
 }
 
-pub async fn handler(_req: Request) -> Result<impl IntoResponse, Error> {
+pub async fn handler(_req: Request) -> Result<Response<Body>, Error> {
     tracing::info!("Choosing a starter Pokemon");
     let starter = choose_starter();
 
@@ -33,7 +33,7 @@ pub async fn handler(_req: Request) -> Result<impl IntoResponse, Error> {
             json!({
               "message": format!("I choose you, {}!", starter),
             })
-            .to_string(),
+            .into(),
         )?;
 
     Ok(response)
diff --git a/examples/simple/api/simple.rs b/examples/simple/api/simple.rs
@@ -1,25 +1,23 @@
 use runtime_demo::choose_starter;
 use serde_json::json;
-use vercel_runtime::{
-    lambda_http::{http::StatusCode, Response},
-    run, Error, IntoResponse, Request,
-};
+use vercel_runtime::{run, Body, Error, Request, Response, StatusCode};
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
     run(handler).await
 }
 
-pub async fn handler(_req: Request) -> Result<impl IntoResponse, Error> {
+pub async fn handler(_req: Request) -> Result<Response<Body>, Error> {
     let starter = choose_starter();
+
     let response = Response::builder()
         .status(StatusCode::OK)
         .header("Content-Type", "application/json")
         .body(
             json!({
               "message": format!("I choose you, {}!", starter),
             })
-            .to_string(),
+            .into(),
         )?;
 
     Ok(response)
diff --git a/vercel_runtime/src/body.rs b/vercel_runtime/src/body.rs
@@ -1,6 +1,7 @@
 //! Provides a Vercel Lambda oriented request and response body entity interface
 use base64::display::Base64Display;
 use serde::ser::{Error as SerError, Serialize, Serializer};
+use serde_json::Value;
 use std::{borrow::Cow, ops::Deref, str};
 
 /// Representation of http request and response bodies as supported
@@ -52,22 +53,17 @@ use std::{borrow::Cow, ops::Deref, str};
 ///   _ => false
 /// })
 /// ```
-#[derive(Debug, PartialEq)]
+#[derive(Default, Debug, PartialEq)]
 pub enum Body {
     /// An empty body
+    #[default]
     Empty,
     /// A body containing string data
     Text(String),
     /// A body containing binary data
     Binary(Vec<u8>),
 }
 
-impl Default for Body {
-    fn default() -> Self {
-        Body::Empty
-    }
-}
-
 impl From<()> for Body {
     fn from(_: ()) -> Self {
         Body::Empty
@@ -149,6 +145,12 @@ impl From<Body> for Vec<u8> {
     }
 }
 
+impl From<Value> for Body {
+    fn from(v: Value) -> Self {
+        Body::Text(v.to_string())
+    }
+}
+
 impl<'a> From<&'a [u8]> for Body {
     fn from(b: &'a [u8]) -> Self {
         Body::Binary(b.to_vec())
diff --git a/vercel_runtime/src/lib.rs b/vercel_runtime/src/lib.rs
@@ -1,21 +1,23 @@
-pub mod body;
-pub mod request;
-pub mod response;
-use body::Body;
-pub use lambda_http;
-use lambda_http::{service_fn, tower::ServiceBuilder};
-pub use lambda_runtime;
+mod body;
+mod request;
+mod response;
 use lambda_runtime::LambdaEvent;
 use request::{VercelEvent, VercelRequest};
-pub use response::IntoResponse;
-use response::VercelResponse;
+use response::EventResponse;
 use std::future::Future;
 use tracing::{debug, error};
 
 pub type Request = lambda_http::http::Request<Body>;
 pub type Error = lambda_http::Error;
+pub type Event<'a> = LambdaEvent<VercelEvent<'a>>;
+pub use body::Body;
+pub use lambda_http::http::StatusCode;
+pub use lambda_http::service_fn;
+pub use lambda_http::tower::ServiceBuilder;
+pub use lambda_http::Response;
+pub use lambda_runtime::run as run_service;
 
-pub async fn run<T: FnMut(Request) -> F, F: Future<Output = Result<impl IntoResponse, Error>>>(
+pub async fn run<T: FnMut(Request) -> F, F: Future<Output = Result<Response<Body>, Error>>>(
     f: T,
 ) -> Result<(), Error> {
     let handler = ServiceBuilder::new()
@@ -26,8 +28,8 @@ pub async fn run<T: FnMut(Request) -> F, F: Future<Output = Result<impl IntoResp
     lambda_runtime::run(handler).await
 }
 
-pub fn process_request(lambda_event: LambdaEvent<VercelEvent>) -> lambda_http::http::Request<Body> {
-    let (event, _context) = lambda_event.into_parts();
+pub fn process_request(event: Event) -> Request {
+    let (event, _context) = event.into_parts();
     let parse_result = serde_json::from_str::<VercelRequest>(&event.body);
 
     match parse_result {
@@ -44,6 +46,6 @@ pub fn process_request(lambda_event: LambdaEvent<VercelEvent>) -> lambda_http::h
     }
 }
 
-pub fn process_response(response: impl IntoResponse) -> VercelResponse {
-    VercelResponse::from(response.into_response())
+pub fn process_response(response: Response<Body>) -> EventResponse {
+    EventResponse::from(response)
 }
diff --git a/vercel_runtime/src/request.rs b/vercel_runtime/src/request.rs
@@ -26,7 +26,7 @@ pub struct VercelEvent<'a> {
     #[allow(dead_code)]
     #[serde(rename = "Action")]
     action: Cow<'a, str>,
-    pub body: Cow<'a, str>,
+    pub(crate) body: Cow<'a, str>,
 }
 
 fn deserialize_method<'de, D>(deserializer: D) -> Result<Method, D::Error>
diff --git a/vercel_runtime/src/response.rs b/vercel_runtime/src/response.rs
