Axum Routing & Handlers

use axum::{routing::{get, post, delete}, Router, Json};
use serde::{Deserialize, Serialize};
 
#[derive(Deserialize)] struct CreateUser { email: String }
#[derive(Serialize)] struct User { id: u64, email: String }
 
async fn create(Json(body): Json<CreateUser>) -> Json<User> {
    Json(User { id: 1, email: body.email })
}
 
let app = Router::new()
    .route("/users", get(list_users).post(create))
    .route("/users/:id", get(get_user).delete(delete_user));

use axum::{
    Router, extract::{Path, State},
    http::StatusCode,
    routing::{delete, get, post},
    Json,
};
use serde::{Deserialize, Serialize};
 
#[derive(Clone, Serialize)]
struct Item { id: u64, name: String }
 
#[derive(Deserialize)]
struct NewItem { name: String }
 
type Store = std::sync::Arc<tokio::sync::RwLock<Vec<Item>>>;
 
async fn list(State(store): State<Store>) -> Json<Vec<Item>> {
    Json(store.read().await.clone())
}
 
async fn create(
    State(store): State<Store>,
    Json(body): Json<NewItem>,
) -> (StatusCode, Json<Item>) {
    let mut guard = store.write().await;
    let item = Item { id: guard.len() as u64 + 1, name: body.name };
    guard.push(item.clone());
    (StatusCode::CREATED, Json(item))
}
 
async fn remove(Path(id): Path<u64>, State(store): State<Store>) -> StatusCode {
    let mut guard = store.write().await;
    if let Some(pos) = guard.iter().position(|i| i.id == id) {
        guard.remove(pos);
        StatusCode::NO_CONTENT
    } else {
        StatusCode::NOT_FOUND
    }
}
 
#[tokio::main]
async fn main() {
    let store = Store::default();
    let app = Router::new()
        .route("/items", get(list).post(create))
        .route("/items/:id", delete(remove))
        .with_state(store);
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

use axum::response::Redirect;
async fn old() -> Redirect { Redirect::permanent("/v2/old") }