Reorganize and consolidate HTTP routes.

HTTP routes are now defined in a single, unified module, pulling them out of the topical modules they were formerly part of.

This is intended to improve the navigability of the codebase. Previously, finding the handler corresponding to a specific endpoint required prior familiarity, though in practice you could usually guess from topic area. Now, all routes are defined in one place; if you know the path, you can read down the list to find the handler.

Handlers themselves live with the domain they are most appropriately "part of," generally (in this version, universally) in a `handlers` submodule. The handlers themselves have been flattened down; rather than representing a path and a method, they now represent a named operation (which is suspiciously similar to the path in most cases). This means that we no longer have constructs like `crate::ui::routes::ch::channel` - it's now `crate::ui::handlers::channel` instead.

## Disclaimer

I Solemnly Swear I Didn't Change Any Handlers.

## Prior art

I've inadvertently reinvented Django's `urls.py` convention, and I've opted to lean into that.

Merges flatter-routes-reorg into main.

1 files changed, 2 insertions, 37 deletions

diff --git a/src/cli.rs b/src/cli.rs
index 7bfdbc0..28c2ec8 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -6,7 +6,6 @@
 use std::{future, io};
 
 use axum::{
-    Router,
     http::header,
     middleware,
     response::{IntoResponse, Response},
@@ -15,7 +14,7 @@ use clap::{CommandFactory, Parser};
 use sqlx::sqlite::SqlitePool;
 use tokio::net;
 
-use crate::{app::App, boot, channel, clock, db, event, expire, invite, message, setup, ui, user};
+use crate::{app::App, clock, db, routes};
 
 /// Command-line entry point for running the `pilcrow` server.
 ///
@@ -82,7 +81,7 @@ impl Args {
         let pool = self.pool().await?;
 
         let app = App::from(pool);
-        let app = routers(&app)
+        let app = routes::routes(&app)
             .route_layer(middleware::from_fn(clock::middleware))
             .route_layer(middleware::map_response(Self::server_info()))
             .with_state(app);
@@ -123,40 +122,6 @@ impl Args {
     }
 }
 
-fn routers(app: &App) -> Router<App> {
-    [
-        [
-            // API endpoints that require setup to function
-            boot::router(),
-            channel::router(),
-            event::router(),
-            invite::router(),
-            user::router(),
-            message::router(),
-        ]
-        .into_iter()
-        .fold(Router::default(), Router::merge)
-        // 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
-        // upside to re-checking expiry tens of times back-to-back like that; the API is accessed
-        // more regularly and with less of a traffic rush.
-        //
-        // This should, probably, be moved to a background job at some point.
-        .route_layer(middleware::from_fn_with_state(
-            app.clone(),
-            expire::middleware,
-        ))
-        .route_layer(setup::Required(app.clone())),
-        // API endpoints that handle setup
-        setup::router(),
-        // The UI (handles setup state itself)
-        ui::router(app),
-    ]
-    .into_iter()
-    .fold(Router::default(), Router::merge)
-}
-
 fn started_msg(listener: &net::TcpListener) -> io::Result<String> {
     let local_addr = listener.local_addr()?;
     Ok(format!("listening on http://{local_addr}/"))