Extractors & State

use axum::extract::{Path, Query, State};
use axum::Json;
use serde::Deserialize;
 
#[derive(Clone)]
struct AppState { pool: sqlx::PgPool }
 
#[derive(Deserialize)]
struct Search { q: Option<String> }
 
async fn handler(
    State(state): State<AppState>,
    Path(id): Path<u64>,
    Query(search): Query<Search>,
    Json(body): Json<CreateDto>,
) -> Result<Json<Item>, AppError> {
    // use state.pool, id, search.q, body
}

use axum::{
    extract::{Path, Query, State},
    routing::get,
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
 
#[derive(Clone)]
struct AppState {
    items: Arc<tokio::sync::RwLock<Vec<String>>>,
}
 
#[derive(Deserialize)]
struct Filter { prefix: Option<String> }
 
#[derive(Serialize)]
struct ItemView { index: usize, name: String }
 
async fn list(
    State(state): State<AppState>,
    Query(filter): Query<Filter>,
) -> Json<Vec<ItemView>> {
    let items = state.items.read().await;
    let views: Vec<_> = items
        .iter()
        .enumerate()
        .filter(|(_, name)| {
            filter.prefix.as_ref().map(|p| name.starts_with(p)).unwrap_or(true)
        })
        .map(|(i, name)| ItemView { index: i, name: name.clone() })
        .collect();
    Json(views)
}
 
async fn get_one(Path(index): Path<usize>, State(state): State<AppState>) -> Json<ItemView> {
    let items = state.items.read().await;
    let name = items.get(index).cloned().unwrap_or_default();
    Json(ItemView { index, name })
}
 
#[tokio::main]
async fn main() {
    let state = AppState {
        items: Arc::new(tokio::sync::RwLock::new(vec!["alpha".into(), "beta".into()])),
    };
    let app = Router::new()
        .route("/items", get(list))
        .route("/items/:index", get(get_one))
        .with_state(state);
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

// Optional extractor - entire param can be absent
use axum::extract::OptionalQuery;
async fn maybe(Query(q): OptionalQuery<Filter>) -> String { /* ... */ }