Add workaround for inference errors after removing B type param (#1835)

Author: davidpdrsn

axum/CHANGELOG.md

@@ -11,9 +11,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **breaking:** Change `sse::Event::json_data` to use `axum_core::Error` as its error type ([#1762])
 - **breaking:** Rename `DefaultOnFailedUpdgrade` to `DefaultOnFailedUpgrade` ([#1664])
 - **breaking:** Rename `OnFailedUpdgrade` to `OnFailedUpgrade` ([#1664])
+- **added:** Add `Router::as_service` to workaround type inference issues when
+  calling `ServiceExt` methods on a `Router` ([#1835])
 
 [#1762]: https://github.com/tokio-rs/axum/pull/1762
 [#1664]: https://github.com/tokio-rs/axum/pull/1664
+[#1835]: https://github.com/tokio-rs/axum/pull/1835
 
 # 0.6.9 (24. February, 2023)
 

axum/src/routing/mod.rs

@@ -16,6 +16,7 @@ use std::{
     collections::HashMap,
     convert::Infallible,
     fmt,
+    marker::PhantomData,
     sync::Arc,
     task::{Context, Poll},
 };
@@ -498,6 +499,66 @@ where
             Endpoint::NestedRouter(router) => router.call_with_state(req, state),
         }
     }
+
+    /// Convert the router into a [`Service`] with a fixed request body type, to aid type
+    /// inference.
+    ///
+    /// In some cases when calling methods from [`tower::ServiceExt`] on a [`Router`] you might get
+    /// type inference errors along the lines of
+    ///
+    /// ```not_rust
+    /// let response = router.ready().await?.call(request).await?;
+    ///                       ^^^^^ cannot infer type for type parameter `B`
+    /// ```
+    ///
+    /// This happens because `Router` implements [`Service`] with `impl<B> Service<Request<B>> for Router<()>`.
+    ///
+    /// For example:
+    ///
+    /// ```compile_fail
+    /// use axum::{
+    ///     Router,
+    ///     routing::get,
+    ///     http::Request,
+    ///     body::Body,
+    /// };
+    /// use tower::{Service, ServiceExt};
+    ///
+    /// # async fn async_main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let mut router = Router::new().route("/", get(|| async {}));
+    /// let request = Request::new(Body::empty());
+    /// let response = router.ready().await?.call(request).await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Calling `Router::as_service` fixes that:
+    ///
+    /// ```
+    /// use axum::{
+    ///     Router,
+    ///     routing::get,
+    ///     http::Request,
+    ///     body::Body,
+    /// };
+    /// use tower::{Service, ServiceExt};
+    ///
+    /// # async fn async_main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let mut router = Router::new().route("/", get(|| async {}));
+    /// let request = Request::new(Body::empty());
+    /// let response = router.as_service().ready().await?.call(request).await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// This is mainly used when calling `Router` in tests. It shouldn't be necessary when running
+    /// the `Router` normally via [`Router::into_make_service`].
+    pub fn as_service<B>(&mut self) -> RouterAsService<'_, B, S> {
+        RouterAsService {
+            router: self,
+            _marker: PhantomData,
+        }
+    }
 }
 
 impl Router {
@@ -560,6 +621,45 @@ where
     }
 }
 
+/// A [`Router`] converted into a service with a fixed body type.
+///
+/// See [`Router::as_service`] for more details.
+pub struct RouterAsService<'a, B, S = ()> {
+    router: &'a mut Router<S>,
+    _marker: PhantomData<B>,
+}
+
+impl<'a, B> Service<Request<B>> for RouterAsService<'a, B, ()>
+where
+    B: HttpBody<Data = bytes::Bytes> + Send + 'static,
+    B::Error: Into<axum_core::BoxError>,
+{
+    type Response = Response;
+    type Error = Infallible;
+    type Future = RouteFuture<Infallible>;
+
+    #[inline]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        <Router as Service<Request<B>>>::poll_ready(self.router, cx)
+    }
+
+    #[inline]
+    fn call(&mut self, req: Request<B>) -> Self::Future {
+        self.router.call(req)
+    }
+}
+
+impl<'a, B, S> fmt::Debug for RouterAsService<'a, B, S>
+where
+    S: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RouterAsService")
+            .field("router", &self.router)
+            .finish()
+    }
+}
+
 /// Wrapper around `matchit::Router` that supports merging two `Router`s.
 #[derive(Clone, Default)]
 struct Node {

examples/hyper-1-0/src/main.rs

@@ -8,13 +8,11 @@ use axum::{routing::get, Router};
 use std::net::SocketAddr;
 use tokio::net::TcpListener;
 use tower_http::trace::TraceLayer;
-use tower_hyper_http_body_compat::{
-    HttpBody1ToHttpBody04, TowerService03HttpServiceAsHyper1HttpService,
-};
+use tower_hyper_http_body_compat::TowerService03HttpServiceAsHyper1HttpService;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
 // this is hyper 1.0
-use hyper::{body::Incoming, server::conn::http1};
+use hyper::server::conn::http1;
 
 #[tokio::main]
 async fn main() {
@@ -26,8 +24,7 @@ async fn main() {
         .with(tracing_subscriber::fmt::layer())
         .init();
 
-    // you have to use `HttpBody1ToHttpBody04<Incoming>` as the second type parameter to `Router`
-    let app: Router<_, HttpBody1ToHttpBody04<Incoming>> = Router::new()
+    let app = Router::new()
         .route("/", get(|| async { "Hello, World!" }))
         // we can still add regular tower middleware
         .layer(TraceLayer::new_for_http());

examples/static-file-server/src/main.rs

@@ -72,10 +72,7 @@ fn using_serve_dir_with_handler_as_service() -> Router {
     }
 
     // you can convert handler function to service
-    let service = tower::ServiceExt::<Request<Body>>::map_err(
-        handle_404.into_service(),
-        |err| -> std::io::Error { match err {} },
-    );
+    let service = handle_404.into_service();
 
     let serve_dir = ServeDir::new("assets").not_found_service(service);
 

examples/testing/src/main.rs

@@ -196,7 +196,14 @@ mod tests {
             .uri("/requires-connect-into")
             .body(Body::empty())
             .unwrap();
-        let response = app.ready().await.unwrap().call(request).await.unwrap();
+        let response = app
+            .as_service()
+            .ready()
+            .await
+            .unwrap()
+            .call(request)
+            .await
+            .unwrap();
         assert_eq!(response.status(), StatusCode::OK);
     }
 }