Handlers are _named operations_, which can be exposed via routes.

Each domain module that exposes handlers does so through a `handlers` child module, ideally as a top-level symbol that can be plugged directly into Axum's `MethodRouter`. Modules could make exceptions to this - kill the doctrinaire inside yourself, after all - but none of the API modules that actually exist need such exceptions, and consistency is useful.

The related details of request types, URL types, response types, errors, &c &c are then organized into modules under `handlers`, along with their respective tests.

1 files changed, 20 insertions, 41 deletions

diff --git a/src/routes.rs b/src/routes.rs
index 5bb5f91..1e66582 100644
--- a/src/routes.rs
+++ b/src/routes.rs
@@ -9,56 +9,35 @@ use crate::{app::App, boot, channel, event, expire, invite, message, setup, ui,
 pub fn routes(app: &App) -> Router<App> {
     // UI routes that can be accessed before the administrator completes setup.
     let ui_bootstrap = Router::new()
-        .route("/{*path}", get(ui::routes::path::get::handler))
-        .route("/setup", get(ui::routes::setup::get::handler));
+        .route("/{*path}", get(ui::handlers::asset))
+        .route("/setup", get(ui::handlers::setup));
 
     // UI routes that require the administrator to complete setup first.
     let ui_setup_required = Router::new()
-        .route("/", get(ui::routes::get::handler))
-        .route("/ch/{channel}", get(ui::routes::ch::channel::get::handler))
-        .route(
-            "/invite/{invite}",
-            get(ui::routes::invite::invite::get::handler),
-        )
-        .route("/login", get(ui::routes::login::get::handler))
-        .route("/me", get(ui::routes::me::get::handler))
+        .route("/", get(ui::handlers::index))
+        .route("/ch/{channel}", get(ui::handlers::channel))
+        .route("/invite/{invite}", get(ui::handlers::invite))
+        .route("/login", get(ui::handlers::login))
+        .route("/me", get(ui::handlers::me))
         .route_layer(crate::setup::Required(app.clone()).with_fallback(Redirect::to("/setup")));
 
     // API routes that can run before the administrator completes setup.
-    let api_bootstrap = Router::new().route("/api/setup", post(setup::routes::post::handler));
+    let api_bootstrap = Router::new().route("/api/setup", post(setup::handlers::setup));
 
     // API routes that require the administrator to complete setup first.
     let api_setup_required = Router::new()
-        .route("/api/auth/login", post(user::routes::login::post::handler))
-        .route(
-            "/api/auth/logout",
-            post(user::routes::logout::post::handler),
-        )
-        .route("/api/boot", get(boot::routes::get::handler))
-        .route("/api/channels", post(channel::routes::post::handler))
-        .route(
-            "/api/channels/{channel}",
-            post(channel::routes::channel::post::handler),
-        )
-        .route(
-            "/api/channels/{channel}",
-            delete(channel::routes::channel::delete::handler),
-        )
-        .route("/api/events", get(event::routes::get::handler))
-        .route("/api/invite", post(invite::routes::post::handler))
-        .route(
-            "/api/invite/{invite}",
-            get(invite::routes::invite::get::handler),
-        )
-        .route(
-            "/api/invite/{invite}",
-            post(invite::routes::invite::post::handler),
-        )
-        .route(
-            "/api/messages/{message}",
-            delete(message::routes::message::delete::handler),
-        )
-        .route("/api/password", post(user::routes::password::post::handler))
+        .route("/api/auth/login", post(user::handlers::login))
+        .route("/api/auth/logout", post(user::handlers::logout))
+        .route("/api/boot", get(boot::handlers::boot))
+        .route("/api/channels", post(channel::handlers::create))
+        .route("/api/channels/{channel}", post(channel::handlers::send))
+        .route("/api/channels/{channel}", delete(channel::handlers::delete))
+        .route("/api/events", get(event::handlers::stream))
+        .route("/api/invite", post(invite::handlers::issue))
+        .route("/api/invite/{invite}", get(invite::handlers::get))
+        .route("/api/invite/{invite}", post(invite::handlers::accept))
+        .route("/api/messages/{message}", delete(message::handlers::delete))
+        .route("/api/password", post(user::handlers::change_password))
         // Run expiry whenever someone accesses the API. This was previously a blanket middleware
         // affecting the whole service, but loading the client makes a several requests before the
         // client can completely load, each of which was triggering expiry. There is absolutely no