Don't require Lambda Service to use lambda_http::Error (#474)

david-perez · web-flow · commit 76d26b9efedd · 2022-05-09T08:06:55.000-07:00
Currently, the `Service` that you pass to `lambda_http::run` is required
to use `lambda_http::Error` as its associated error type, a type-erased
boxed error type. However, all the runtime needs is for the error type
to implement `Debug` and `Display`. This commit relaxes this constraint,
allowing users to run a broader class of `Service`s.
diff --git a/lambda-http/examples/shared-resources-example.rs b/lambda-http/examples/shared-resources-example.rs
@@ -1,4 +1,4 @@
-use lambda_http::{service_fn, Error, IntoResponse, Request, RequestExt, Response};
+use lambda_http::{service_fn, Body, Error, IntoResponse, Request, RequestExt, Response};
 
 struct SharedClient {
     name: &'static str,
@@ -20,15 +20,17 @@ async fn main() -> Result<(), Error> {
 
     // Define a closure here that makes use of the shared client.
     let handler_func_closure = move |event: Request| async move {
-        Ok(match event.query_string_parameters().first("first_name") {
-            Some(first_name) => shared_client_ref
-                .response(event.lambda_context().request_id, first_name)
-                .into_response(),
-            _ => Response::builder()
-                .status(400)
-                .body("Empty first name".into())
-                .expect("failed to render response"),
-        })
+        Result::<Response<Body>, std::convert::Infallible>::Ok(
+            match event.query_string_parameters().first("first_name") {
+                Some(first_name) => shared_client_ref
+                    .response(event.lambda_context().request_id, first_name)
+                    .into_response(),
+                _ => Response::builder()
+                    .status(400)
+                    .body("Empty first name".into())
+                    .expect("failed to render response"),
+            },
+        )
     };
 
     // Pass the closure to the runtime here.
diff --git a/lambda-http/src/lib.rs b/lambda-http/src/lib.rs
@@ -23,7 +23,9 @@
 //! async fn main() -> Result<(), Error> {
 //!     // initialize dependencies once here for the lifetime of your
 //!     // lambda task
-//!     lambda_http::run(service_fn(|request| async { Ok("👋 world!") })).await?;
+//!     lambda_http::run(service_fn(|request| async {
+//!         Result::<&str, std::convert::Infallible>::Ok("👋 world!")
+//!     })).await?;
 //!     Ok(())
 //! }
 //! ```
@@ -44,7 +46,7 @@
 //!
 //! async fn hello(
 //!     request: Request
-//! ) -> Result<impl IntoResponse, Error> {
+//! ) -> Result<impl IntoResponse, std::convert::Infallible> {
 //!     let _context = request.lambda_context();
 //!
 //!     Ok(format!(
@@ -119,9 +121,9 @@ pub struct Adapter<'a, R, S> {
     _phantom_data: PhantomData<&'a R>,
 }
 
-impl<'a, R, S> From<S> for Adapter<'a, R, S>
+impl<'a, R, S, E> From<S> for Adapter<'a, R, S>
 where
-    S: Service<Request, Response = R, Error = Error>,
+    S: Service<Request, Response = R, Error = E>,
     S::Future: 'a,
     R: IntoResponse,
 {
@@ -133,14 +135,14 @@ where
     }
 }
 
-impl<'a, R, S> Service<LambdaEvent<LambdaRequest>> for Adapter<'a, R, S>
+impl<'a, R, S, E> Service<LambdaEvent<LambdaRequest>> for Adapter<'a, R, S>
 where
-    S: Service<Request, Response = R, Error = Error>,
+    S: Service<Request, Response = R, Error = E>,
     S::Future: 'a,
     R: IntoResponse,
 {
     type Response = LambdaResponse;
-    type Error = Error;
+    type Error = E;
     type Future = TransformResponse<'a, R, Self::Error>;
 
     fn poll_ready(&mut self, _cx: &mut core::task::Context<'_>) -> core::task::Poll<Result<(), Self::Error>> {
@@ -160,11 +162,12 @@ where
 ///
 /// This takes care of transforming the LambdaEvent into a [`Request`] and then
 /// converting the result into a [`LambdaResponse`].
-pub async fn run<'a, R, S>(handler: S) -> Result<(), Error>
+pub async fn run<'a, R, S, E>(handler: S) -> Result<(), Error>
 where
-    S: Service<Request, Response = R, Error = Error>,
+    S: Service<Request, Response = R, Error = E>,
     S::Future: 'a,
     R: IntoResponse,
+    E: std::fmt::Debug + std::fmt::Display,
 {
     lambda_runtime::run(Adapter::from(handler)).await
 }
