State & Dependency Injection

use std::sync::Arc;

use axum::{Router, extract::State, routing::get};

#[derive(Clone)]
struct AppState {
    library_name: Arc<str>,
    http: reqwest::Client, // already an Arc inside: cheap to clone
}

async fn home(State(state): State<AppState>) -> String {
    format!("Welcome to {}\n", state.library_name)
}

fn api() -> Router<AppState> {
    // still *needs* an AppState: it is not given one here
    Router::new().route("/ping", get(|State(s): State<AppState>| async move { format!("{} api\n", s.library_name) }))
}

fn app(state: AppState) -> Router {
    Router::new()
        .route("/", get(home))
        .nest("/api/v1", api())
        .with_state(state) // Router<AppState> -> Router<()>
}

#[tokio::main]
async fn main() {
    let state = AppState { library_name: Arc::from("Bookshelf"), http: reqwest::Client::new() };
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app(state)).await.unwrap();
}

error[E0308]: mismatched types
 --> src/app.rs:6:30
  |
6 |     Router::new().route("/", get(home))
  |                   -----      ^^^^^^^^^ expected `MethodRouter`, found `MethodRouter<AppState>`
  |
  = note: expected struct `MethodRouter<()>`
             found struct `MethodRouter<AppState>`

use std::sync::Arc;

use axum::{
    Router,
    extract::{FromRef, State},
    routing::get,
};

#[derive(Debug)]
struct Settings {
    library_name: String,
    max_loans: u8,
}

#[derive(Clone, Default)]
struct Metrics {
    requests: Arc<std::sync::atomic::AtomicU64>,
}

#[derive(Clone, FromRef)]
struct AppState {
    settings: Arc<Settings>,
    metrics: Metrics,
}

// Needs only the settings: works with any state that provides an Arc<Settings>.
async fn loan_policy(State(settings): State<Arc<Settings>>) -> String {
    format!("{} lends up to {} books\n", settings.library_name, settings.max_loans)
}

async fn hits(State(metrics): State<Metrics>) -> String {
    let n = metrics.requests.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
    format!("{n} hits\n")
}

#[tokio::main]
async fn main() {
    let state = AppState {
        settings: Arc::new(Settings { library_name: "Bookshelf".into(), max_loans: 5 }),
        metrics: Metrics::default(),
    };
    let app = Router::new().route("/policy", get(loan_policy)).route("/hits", get(hits)).with_state(state);
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

use std::collections::HashMap;
use std::sync::{Arc, RwLock};

use axum::{
    Json, Router,
    extract::{Path, State},
    http::StatusCode,
    routing::{get, put},
};

#[derive(Clone, Default)]
struct AppState {
    // short critical sections, no .await inside: std RwLock
    ratings: Arc<RwLock<HashMap<String, Vec<u8>>>>,
}

async fn rate(State(state): State<AppState>, Path(isbn): Path<String>, Json(stars): Json<u8>) -> StatusCode {
    if !(1..=5).contains(&stars) {
        return StatusCode::UNPROCESSABLE_ENTITY;
    }
    state.ratings.write().expect("ratings lock poisoned").entry(isbn).or_default().push(stars);
    StatusCode::NO_CONTENT
}

async fn average(State(state): State<AppState>, Path(isbn): Path<String>) -> Result<String, StatusCode> {
    let avg = {
        let ratings = state.ratings.read().expect("ratings lock poisoned");
        let r = ratings.get(&isbn).ok_or(StatusCode::NOT_FOUND)?;
        f64::from(r.iter().map(|&s| u32::from(s)).sum::<u32>()) / r.len() as f64
    }; // read guard dropped here
    tokio::task::yield_now().await; // safe: no guard alive
    Ok(format!("{avg:.1}\n"))
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/books/{isbn}/rating", put(rate).get(average))
        .with_state(AppState::default());
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

use std::sync::Arc;

use axum::{
    Router,
    extract::{Path, State},
    http::StatusCode,
    routing::get,
};
use futures::future::BoxFuture;

pub trait BookRepo: Send + Sync {
    fn title(&self, isbn: String) -> BoxFuture<'_, Option<String>>;
}

struct FixedRepo;

impl BookRepo for FixedRepo {
    fn title(&self, isbn: String) -> BoxFuture<'_, Option<String>> {
        Box::pin(async move { (isbn == "9780441013593").then(|| "Dune".to_owned()) })
    }
}

#[derive(Clone)]
struct AppState {
    books: Arc<dyn BookRepo>,
}

async fn title(State(state): State<AppState>, Path(isbn): Path<String>) -> Result<String, StatusCode> {
    state.books.title(isbn).await.ok_or(StatusCode::NOT_FOUND)
}

pub fn app(books: Arc<dyn BookRepo>) -> Router {
    Router::new().route("/books/{isbn}/title", get(title)).with_state(AppState { books })
}

#[tokio::main]
async fn main() {
    // main wires the real adapter; tests call app(Arc::new(FakeRepo)) instead
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app(Arc::new(FixedRepo))).await.unwrap();
}