Change how Resources are added to Routers (#544)

axum-extra/src/routing/mod.rs

@@ -1,6 +1,6 @@
 //! Additional types for defining routes.
 
-use axum::Router;
+use axum::{body::Body, Router};
 
 mod resource;
 
@@ -8,24 +8,55 @@ pub use self::resource::Resource;
 
 /// Extension trait that adds additional methods to [`Router`].
 pub trait RouterExt<B>: sealed::Sealed {
-    /// Add a [`Resource`] to the router.
+    /// Add the routes from `T`'s [`HasRoutes::routes`] to this router.
     ///
-    /// See [`Resource`] for more details.
+    /// # Example
-    fn resource<F>(self, name: &str, f: F) -> Self
+    ///
+    /// Using [`Resource`] which implements [`HasRoutes`]:
+    ///
+    /// ```rust
+    /// use axum::{Router, routing::get};
+    /// use axum_extra::routing::{RouterExt, Resource};
+    ///
+    /// let app = Router::new()
+    ///     .with(
+    ///         Resource::named("users")
+    ///             .index(|| async {})
+    ///             .create(|| async {})
+    ///     )
+    ///     .with(
+    ///         Resource::named("teams").index(|| async {})
+    ///     );
+    /// # let _: Router<axum::body::Body> = app;
+    /// ```
+    fn with<T>(self, routes: T) -> Self
     where
-        F: FnOnce(resource::Resource<B>) -> resource::Resource<B>;
+        T: HasRoutes<B>;
 }
 
-impl<B> RouterExt<B> for Router<B> {
+impl<B> RouterExt<B> for Router<B>
-    fn resource<F>(self, name: &str, f: F) -> Self
 where
-        F: FnOnce(resource::Resource<B>) -> resource::Resource<B>,
+    B: Send + 'static,
 {
-        f(resource::Resource {
+    fn with<T>(self, routes: T) -> Self
-            name: name.to_owned(),
+    where
-            router: self,
+        T: HasRoutes<B>,
-        })
+    {
-        .router
+        self.merge(routes.routes())
+    }
+}
+
+/// Trait for things that can provide routes.
+///
+/// Used with [`RouterExt::with`].
+pub trait HasRoutes<B = Body> {
+    /// Get the routes.
+    fn routes(self) -> Router<B>;
+}
+
+impl<B> HasRoutes<B> for Router<B> {
+    fn routes(self) -> Router<B> {
+        self
     }
 }
 

axum-extra/src/routing/resource.rs

@@ -1,3 +1,4 @@
+use super::HasRoutes;
 use axum::{
     body::{Body, BoxBody},
     handler::Handler,
@@ -14,11 +15,11 @@ use tower_service::Service;
 ///
 /// ```rust
 /// use axum::{Router, routing::get, extract::Path};
-/// use axum_extra::routing::RouterExt;
+/// use axum_extra::routing::{RouterExt, Resource};
 ///
-/// let app = Router::new().resource("users", |r| {
+/// let users = Resource::named("users")
 ///     // Define a route for `GET /users`
-///     r.index(|| async {})
+///     .index(|| async {})
 ///     // `POST /users`
 ///     .create(|| async {})
 ///     // `GET /users/new`
@@ -41,8 +42,9 @@ use tower_service::Service;
 ///     // This defines a route for `GET /users/featured`
 ///     .nest_collection(
 ///         Router::new().route("/featured", get(|| async {})),
-///         )
+///     );
-/// });
+///
+/// let app = Router::new().with(users);
 /// # let _: Router<axum::body::Body> = app;
 /// ```
 #[derive(Debug)]
@@ -52,27 +54,17 @@ pub struct Resource<B = Body> {
 }
 
 impl<B: Send + 'static> Resource<B> {
-    fn index_create_path(&self) -> String {
+    /// Create a `Resource` with the given name.
-        format!("/{}", self.name)
+    ///
+    /// All routes will be nested at `/{resource_name}`.
+    pub fn named(resource_name: &str) -> Self {
+        Self {
+            name: resource_name.to_string(),
+            router: Default::default(),
+        }
     }
 
-    fn show_update_destroy_path(&self) -> String {
+    /// Add a handler at `GET /{resource_name}`.
-        format!("/{0}/:{0}_id", self.name)
-    }
-
-    fn route<T>(mut self, path: &str, svc: T) -> Self
-    where
-        T: Service<Request<B>, Response = Response<BoxBody>, Error = Infallible>
-            + Clone
-            + Send
-            + 'static,
-        T::Future: Send + 'static,
-    {
-        self.router = self.router.route(path, svc);
-        self
-    }
-
-    /// Add a handler at `GET /resource_name`.
     pub fn index<H, T>(self, handler: H) -> Self
     where
         H: Handler<T, B>,
@@ -173,6 +165,32 @@ impl<B: Send + 'static> Resource<B> {
         self.router = self.router.nest(&path, svc);
         self
     }
+
+    fn index_create_path(&self) -> String {
+        format!("/{}", self.name)
+    }
+
+    fn show_update_destroy_path(&self) -> String {
+        format!("/{0}/:{0}_id", self.name)
+    }
+
+    fn route<T>(mut self, path: &str, svc: T) -> Self
+    where
+        T: Service<Request<B>, Response = Response<BoxBody>, Error = Infallible>
+            + Clone
+            + Send
+            + 'static,
+        T::Future: Send + 'static,
+    {
+        self.router = self.router.route(path, svc);
+        self
+    }
+}
+
+impl<B> HasRoutes<B> for Resource<B> {
+    fn routes(self) -> Router<B> {
+        self.router
+    }
 }
 
 #[cfg(test)]
@@ -185,8 +203,8 @@ mod tests {
 
     #[tokio::test]
     async fn works() {
-        let mut app = Router::new().resource("users", |r| {
+        let users = Resource::named("users")
-            r.index(|| async { "users#index" })
+            .index(|| async { "users#index" })
             .create(|| async { "users#create" })
             .new(|| async { "users#new" })
             .show(|Path(id): Path<u64>| async move { format!("users#show id={}", id) })
@@ -199,8 +217,9 @@ mod tests {
             ))
             .nest_collection(
                 Router::new().route("/featured", get(|| async move { "users#featured" })),
-                )
+            );
-        });
+
+        let mut app = Router::new().with(users);
 
         assert_eq!(
             call_route(&mut app, Method::GET, "/users").await,