feat: convert request event

this is similar to how smithy-typescript deals with this
https://github.com/awslabs/smithy-typescript/tree/main/smithy-typescript-ssdk-libs/server-apigateway

using raw path here:
https://github.com/awslabs/smithy-typescript/blob/ac8fb3f406807bfd14a8f7be8d938377bde36189/smithy-typescript-ssdk-libs/server-apigateway/src/lambda.ts#L51-L59

Author: hugobast

rust-runtime/aws-smithy-http-server/examples/pokemon-service/src/main.rs

@@ -57,7 +57,7 @@ pub async fn run_lambda() {
             .layer(AddExtensionLayer::new(shared_state)),
     );
 
-    let lambda = lambda_http::run(app);
+    let lambda = lambda_http::run(app.into_make_lambda_service());
 
     if let Err(err) = lambda.await {
         eprintln!("lambda error: {}", err);

rust-runtime/aws-smithy-http-server/src/routing/into_make_lambda_service.rs

@@ -0,0 +1,71 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+use http::uri;
+use lambda_http::{Request, RequestExt};
+use std::{
+    fmt::Debug,
+    task::{Context, Poll},
+};
+use tower::Service;
+
+/// A [`MakeService`] that produces AWS Lambda compliant services.
+///
+/// [`MakeService`]: tower::make::MakeService
+#[derive(Debug, Clone)]
+pub struct IntoMakeLambdaService<S> {
+    service: S,
+}
+
+impl<S> IntoMakeLambdaService<S> {
+    pub fn new(service: S) -> Self {
+        Self { service }
+    }
+}
+
+impl<S> Service<Request> for IntoMakeLambdaService<S>
+where
+    S: Service<Request>,
+{
+    type Error = S::Error;
+    type Response = S::Response;
+    type Future = S::Future;
+
+    #[inline]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(cx).map_err(|err| err.into())
+    }
+
+    fn call(&mut self, event: Request) -> Self::Future {
+        self.service.call(convert_event(event))
+    }
+}
+
+fn convert_event(request: Request) -> Request {
+    let raw_path = request.raw_http_path();
+    let (mut parts, body) = request.into_parts();
+    let mut path = String::from(parts.uri.path());
+
+    if !raw_path.is_empty() && raw_path != path {
+        path = raw_path;
+
+        let uri_parts: uri::Parts = parts.uri.into();
+        let path_and_query = uri_parts.path_and_query.unwrap();
+
+        if let Some(query) = path_and_query.query() {
+            path.push('?');
+            path.push_str(query);
+        }
+
+        parts.uri = uri::Uri::builder()
+            .authority(uri_parts.authority.unwrap())
+            .scheme(uri_parts.scheme.unwrap())
+            .path_and_query(path)
+            .build()
+            .unwrap();
+    }
+
+    http::Request::from_parts(parts, body)
+}

rust-runtime/aws-smithy-http-server/src/routing/mod.rs

@@ -7,6 +7,7 @@
 //!
 //! [Smithy specification]: https://awslabs.github.io/smithy/1.0/spec/core/http-traits.html
 
+use self::into_make_lambda_service::IntoMakeLambdaService;
 use self::request_spec::RequestSpec;
 use self::tiny_map::TinyMap;
 use crate::body::{boxed, Body, BoxBody, HttpBody};
@@ -24,6 +25,7 @@ use tower::{Service, ServiceBuilder};
 use tower_http::map_response_body::MapResponseBodyLayer;
 
 mod future;
+mod into_make_lambda_service;
 mod into_make_service;
 
 #[doc(hidden)]
@@ -137,6 +139,18 @@ where
         IntoMakeService::new(self)
     }
 
+    /// Convert this router into a [`MakeService`], that is a [`Service`] whose
+    /// response is another service.
+    ///
+    /// This is useful when running your application with AWS Lambda's
+    /// [`run`].
+    ///
+    /// [`run`]: lambda_http::run
+    /// [`MakeService`]: tower::make::MakeService
+    pub fn into_make_lambda_service(self) -> IntoMakeLambdaService<Self> {
+        IntoMakeLambdaService::new(self)
+    }
+
     /// Apply a [`tower::Layer`] to the router.
     ///
     /// All requests to the router will be processed by the layer's