Routing

use axum::{
    Router,
    extract::Path,
    routing::{delete, get, post},
};

async fn list_books() -> &'static str { "all books" }
async fn create_book() -> &'static str { "created" }
async fn show_book(Path(isbn): Path<String>) -> String { format!("book {isbn}") }
async fn replace_book(Path(isbn): Path<String>) -> String { format!("replaced {isbn}") }
async fn delete_book(Path(isbn): Path<String>) -> String { format!("deleted {isbn}") }
async fn lend_book(Path(isbn): Path<String>) -> String { format!("lent {isbn}") }

fn books_router() -> Router {
    Router::new()
        .route("/api/v1/books", get(list_books).post(create_book))
        .route("/api/v1/books/{isbn}", get(show_book).put(replace_book).delete(delete_book))
        .route("/api/v1/books/{isbn}/loans", post(lend_book))
        // a separate `route` call for the same path adds methods to the existing MethodRouter:
        .route("/api/v1/books/{isbn}/copies", delete(|| async { "copies removed" }))
}

#[tokio::main]
async fn main() {
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, books_router()).await.unwrap();
}

use axum::{
    Router,
    http::Method,
    routing::{MethodFilter, any, on},
};

async fn search(method: Method) -> String {
    format!("search via {method}")
}

async fn webhook(method: Method) -> String {
    format!("webhook received a {method}")
}

fn app() -> Router {
    Router::new()
        // GET with a query string, or POST with a form body: same handler
        .route("/search", on(MethodFilter::GET.or(MethodFilter::POST), search))
        // every method, e.g. for a proxy or a webhook receiver
        .route("/hooks/github", any(webhook))
}

#[tokio::main]
async fn main() {
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app()).await.unwrap();
}

use axum::{Router, extract::{MatchedPath, Path}, routing::get};

fn app() -> Router {
    Router::new()
        .route("/books/new", get(|| async { "the new-book form" }))           // static
        .route("/books/{isbn}", get(|Path(isbn): Path<String>| async move { format!("book {isbn}") }))
        .route("/files/{*path}", get(|Path(p): Path<String>| async move { format!("file {p}") }))
        .route("/{*rest}", get(|m: MatchedPath| async move { format!("catch-all {}", m.as_str()) }))
}

#[tokio::main]
async fn main() {
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app()).await.unwrap();
}

$ curl localhost:3000/books/new
the new-book form
$ curl localhost:3000/books/9780441013593
book 9780441013593
$ curl localhost:3000/files/covers/dune.jpg
file covers/dune.jpg
$ curl localhost:3000/books/
catch-all /{*rest}

use axum::{Router, ServiceExt, extract::Request, routing::get};
use tower::Layer;
use tower_http::normalize_path::NormalizePathLayer;

#[tokio::main]
async fn main() {
    let router = Router::new().route("/books", get(|| async { "all books" }));

    // `/books/` is rewritten to `/books` before the router sees it.
    let app = NormalizePathLayer::trim_trailing_slash().layer(router);

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, ServiceExt::<Request>::into_make_service(app)).await.unwrap();
}

use axum::{
    Router,
    http::{HeaderMap, Method, header},
    response::IntoResponse,
    routing::get,
};

async fn catalogue_export(method: Method) -> impl IntoResponse {
    let mut headers = HeaderMap::new();
    headers.insert(header::CONTENT_TYPE, "text/csv".parse().unwrap());
    if method == Method::HEAD {
        return (headers, String::new()); // headers only: skip the expensive export
    }
    (headers, "isbn,title\n9780441013593,Dune\n".to_owned())
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/exports/catalogue.csv", get(catalogue_export));
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

use std::time::Duration;

use axum::{Router, extract::DefaultBodyLimit, http::StatusCode, routing::{get, post}};
use tower_http::timeout::TimeoutLayer;

async fn upload_cover() -> &'static str { "uploaded" }
async fn export() -> &'static str { "export" }

fn app() -> Router {
    Router::new()
        .route(
            "/api/v1/books/{isbn}/cover",
            post(upload_cover).layer(DefaultBodyLimit::max(5 * 1024 * 1024)), // 5 MiB for this route only
        )
        .route(
            "/api/v1/exports",
            get(export).layer(TimeoutLayer::with_status_code(StatusCode::REQUEST_TIMEOUT, Duration::from_secs(60))),
        )
}

#[tokio::main]
async fn main() {
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app()).await.unwrap();
}