JSON REST APIs

use std::collections::BTreeMap;
use std::ops::Bound;
use std::sync::{Arc, RwLock};

use axum::{
    Json, Router,
    extract::{Path, Query, State, rejection::JsonRejection},
    http::{HeaderMap, StatusCode, header},
    response::{IntoResponse, Response},
    routing::get,
};
use serde::{Deserialize, Serialize};
use serde_json::json;

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Book {
    isbn: String,
    title: String,
    author: String,
    year: u16,
    #[serde(skip_serializing_if = "Option::is_none")]
    subtitle: Option<String>,
    #[serde(skip)] // never part of the representation
    version: u64,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
struct BookInput {
    isbn: String,
    title: String,
    author: String,
    year: u16,
    subtitle: Option<String>,
}

#[derive(Clone, Default)]
struct AppState {
    books: Arc<RwLock<BTreeMap<String, Book>>>,
}

// ---- errors ----
enum ApiError {
    NotFound,
    Conflict(&'static str),
    Unprocessable(String),
    PreconditionFailed,
    BadBody(JsonRejection),
}

impl From<JsonRejection> for ApiError {
    fn from(r: JsonRejection) -> Self {
        ApiError::BadBody(r)
    }
}

impl IntoResponse for ApiError {
    fn into_response(self) -> Response {
        let (status, detail) = match self {
            ApiError::NotFound => (StatusCode::NOT_FOUND, "no such book".to_owned()),
            ApiError::Conflict(msg) => (StatusCode::CONFLICT, msg.to_owned()),
            ApiError::Unprocessable(msg) => (StatusCode::UNPROCESSABLE_ENTITY, msg),
            ApiError::PreconditionFailed => (StatusCode::PRECONDITION_FAILED, "the book was modified".to_owned()),
            ApiError::BadBody(r) => (r.status(), r.body_text()),
        };
        let body = json!({ "type": "about:blank", "title": status.canonical_reason(), "status": status.as_u16(), "detail": detail });
        (status, [(header::CONTENT_TYPE, "application/problem+json")], body.to_string()).into_response()
    }
}

// ---- listing: filtering, sorting, keyset pagination ----
#[derive(Deserialize)]
struct ListParams {
    author: Option<String>,
    q: Option<String>,
    #[serde(default)]
    sort: Sort,
    limit: Option<usize>,
    cursor: Option<String>, // the last ISBN of the previous page
}

#[derive(Deserialize, Default, PartialEq)]
#[serde(rename_all = "lowercase")]
enum Sort {
    #[default]
    Isbn,
    Year,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct Page {
    items: Vec<Book>,
    #[serde(skip_serializing_if = "Option::is_none")]
    next_cursor: Option<String>,
}

async fn list(State(state): State<AppState>, Query(p): Query<ListParams>) -> Result<Json<Page>, ApiError> {
    if p.sort == Sort::Year && p.cursor.is_some() {
        return Err(ApiError::Unprocessable("cursor pagination is only supported with sort=isbn".into()));
    }
    let limit = p.limit.unwrap_or(20).clamp(1, 100);
    let books = state.books.read().expect("lock poisoned");
    // keyset: start strictly after the cursor
    let lower = p.cursor.clone().map_or(Bound::Unbounded, Bound::Excluded);
    let mut items: Vec<Book> = books
        .range((lower, Bound::Unbounded))
        .map(|(_, b)| b)
        .filter(|b| p.author.as_ref().is_none_or(|a| b.author.eq_ignore_ascii_case(a)))
        .filter(|b| p.q.as_ref().is_none_or(|q| b.title.to_lowercase().contains(&q.to_lowercase())))
        .take(limit + 1)
        .cloned()
        .collect();
    let next_cursor = (items.len() > limit).then(|| {
        items.truncate(limit);
        items.last().map(|b| b.isbn.clone()).unwrap_or_default()
    });
    if p.sort == Sort::Year {
        items.sort_by_key(|b| b.year);
    }
    Ok(Json(Page { items, next_cursor }))
}

// ---- create: 201 + Location, 409, 422 ----
async fn create(
    State(state): State<AppState>,
    payload: Result<Json<BookInput>, JsonRejection>,
) -> Result<Response, ApiError> {
    let Json(input) = payload?;
    if input.isbn.len() != 13 || !input.isbn.bytes().all(|c| c.is_ascii_digit()) {
        return Err(ApiError::Unprocessable("isbn must be 13 digits".into()));
    }
    let mut books = state.books.write().expect("lock poisoned");
    if books.contains_key(&input.isbn) {
        return Err(ApiError::Conflict("a book with this ISBN already exists"));
    }
    let book = Book { isbn: input.isbn, title: input.title, author: input.author, year: input.year, subtitle: input.subtitle, version: 1 };
    books.insert(book.isbn.clone(), book.clone());
    let location = format!("/api/v1/books/{}", book.isbn);
    Ok((StatusCode::CREATED, [(header::LOCATION, location), (header::ETAG, etag(&book))], Json(book)).into_response())
}

fn etag(book: &Book) -> String {
    format!("\"{}-v{}\"", book.isbn, book.version)
}

// ---- read with ETag ----
async fn show(State(state): State<AppState>, Path(isbn): Path<String>) -> Result<Response, ApiError> {
    let books = state.books.read().expect("lock poisoned");
    let book = books.get(&isbn).ok_or(ApiError::NotFound)?;
    Ok(([(header::ETAG, etag(book))], Json(book.clone())).into_response())
}

// ---- replace with optimistic concurrency (If-Match) ----
async fn replace(
    State(state): State<AppState>,
    Path(isbn): Path<String>,
    headers: HeaderMap,
    payload: Result<Json<BookInput>, JsonRejection>,
) -> Result<Response, ApiError> {
    let Json(input) = payload?;
    if input.isbn != isbn {
        return Err(ApiError::Unprocessable("the body's isbn must match the URL".into()));
    }
    let mut books = state.books.write().expect("lock poisoned");
    let book = books.get_mut(&isbn).ok_or(ApiError::NotFound)?;
    match headers.get(header::IF_MATCH).and_then(|v| v.to_str().ok()) {
        Some(tag) if tag == etag(book) => {}
        Some(_) => return Err(ApiError::PreconditionFailed),
        None => return Err(ApiError::Unprocessable("If-Match is required".into())), // RFC 6585 suggests 428
    }
    *book = Book { isbn: input.isbn, title: input.title, author: input.author, year: input.year, subtitle: input.subtitle, version: book.version + 1 };
    Ok(([(header::ETAG, etag(book))], Json(book.clone())).into_response())
}

async fn remove(State(state): State<AppState>, Path(isbn): Path<String>) -> Result<StatusCode, ApiError> {
    state.books.write().expect("lock poisoned").remove(&isbn).map(|_| StatusCode::NO_CONTENT).ok_or(ApiError::NotFound)
}

fn app(state: AppState) -> Router {
    Router::new()
        .route("/api/v1/books", get(list).post(create))
        .route("/api/v1/books/{isbn}", get(show).put(replace).delete(remove))
        .with_state(state)
}

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

$ curl -si -H 'content-type: application/json' localhost:3000/api/v1/books \
    -d '{"isbn":"9780441013593","title":"Dune","author":"Frank Herbert","year":1965}'
HTTP/1.1 201 Created
content-type: application/json
location: /api/v1/books/9780441013593
etag: "9780441013593-v1"
...
{"isbn":"9780441013593","title":"Dune","author":"Frank Herbert","year":1965}

$ curl -s -H 'content-type: application/json' localhost:3000/api/v1/books \
    -d '{"isbn":"9780441013593","title":"Dune","author":"Frank Herbert","year":1965}'
{"detail":"a book with this ISBN already exists","status":409,"title":"Conflict","type":"about:blank"}

$ curl -s -X PUT -H 'if-match: "9780441013593-v0"' -H 'content-type: application/json' \
    localhost:3000/api/v1/books/9780441013593 \
    -d '{"isbn":"9780441013593","title":"Dune","author":"Frank Herbert","year":1965,"subtitle":"Book One"}'
{"detail":"the book was modified","status":412,"title":"Precondition Failed","type":"about:blank"}

$ curl -s 'localhost:3000/api/v1/books?author=frank%20herbert&limit=1'
{"items":[{"isbn":"9780441013593","title":"Dune","author":"Frank Herbert","year":1965}]}