feat: author pages with /authors/:id route (0.16.0)

- `GET /v1/authors/:id` returns `AuthorWithCount` (id, name, manga_count).
- `GET /v1/authors/:id/mangas` paged works by that author.
- `GET /v1/authors?search=` autocomplete (already used by Phase 1 forms;
  now formally exposed).
- New `/authors/:id` page on the frontend; author chips on the manga
  detail page (added in Phase 1) now link to a real page.
- Extracts `lib/components/MangaCard.svelte` — already used by the home
  page, ready for the collection page in Phase 3.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
MechaCat02
2026-05-17 14:39:11 +02:00
parent 59d380b6d7
commit 5e92a2c450
12 changed files with 739 additions and 96 deletions

View File

@@ -0,0 +1,276 @@
mod common;
use axum::http::StatusCode;
use serde_json::{json, Value};
use sqlx::PgPool;
use tower::ServiceExt;
use uuid::Uuid;
use common::MultipartBuilder;
async fn create_manga(
app: &axum::Router,
cookie: &str,
metadata: Value,
) -> Value {
let resp = app
.clone()
.oneshot(common::post_multipart_with_cookie(
"/api/v1/mangas",
MultipartBuilder::new().add_json("metadata", metadata),
cookie,
))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::CREATED);
common::body_json(resp).await
}
fn first_author_id(manga: &Value) -> String {
manga["authors"][0]["id"].as_str().unwrap().to_string()
}
#[sqlx::test(migrations = "./migrations")]
async fn get_returns_name_and_manga_count(pool: PgPool) {
let h = common::harness(pool);
let (_, cookie) = common::register_user(&h.app).await;
let m1 = create_manga(
&h.app,
&cookie,
json!({ "title": "Berserk", "authors": ["Kentaro Miura"] }),
)
.await;
// A second manga by the same author bumps the count to 2.
let _ = create_manga(
&h.app,
&cookie,
json!({ "title": "Berserk Prelude", "authors": ["Kentaro Miura"] }),
)
.await;
let author_id = first_author_id(&m1);
let resp = h
.app
.oneshot(common::get(&format!("/api/v1/authors/{author_id}")))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
let body = common::body_json(resp).await;
assert_eq!(body["id"], author_id);
assert_eq!(body["name"], "Kentaro Miura");
assert_eq!(body["manga_count"], 2);
}
#[sqlx::test(migrations = "./migrations")]
async fn get_unknown_id_is_404_with_envelope(pool: PgPool) {
let h = common::harness(pool);
let resp = h
.app
.oneshot(common::get(&format!("/api/v1/authors/{}", Uuid::new_v4())))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
let body = common::body_json(resp).await;
assert_eq!(body["error"]["code"], "not_found");
}
#[sqlx::test(migrations = "./migrations")]
async fn list_mangas_returns_only_works_by_that_author(pool: PgPool) {
let h = common::harness(pool);
let (_, cookie) = common::register_user(&h.app).await;
let m_miura = create_manga(
&h.app,
&cookie,
json!({ "title": "Berserk", "authors": ["Kentaro Miura"] }),
)
.await;
let _ = create_manga(
&h.app,
&cookie,
json!({ "title": "One Piece", "authors": ["Eiichiro Oda"] }),
)
.await;
let _ = create_manga(
&h.app,
&cookie,
json!({ "title": "Berserk Prelude", "authors": ["Kentaro Miura"] }),
)
.await;
let author_id = first_author_id(&m_miura);
let resp = h
.app
.oneshot(common::get(&format!("/api/v1/authors/{author_id}/mangas")))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
let body = common::body_json(resp).await;
let titles: Vec<&str> = body["items"]
.as_array()
.unwrap()
.iter()
.map(|m| m["title"].as_str().unwrap())
.collect();
// Sorted by created_at DESC — Berserk Prelude was created last.
assert_eq!(titles, vec!["Berserk Prelude", "Berserk"]);
assert_eq!(body["page"]["total"], 2);
}
#[sqlx::test(migrations = "./migrations")]
async fn list_mangas_paginates(pool: PgPool) {
let h = common::harness(pool);
let (_, cookie) = common::register_user(&h.app).await;
let mut author_id = String::new();
for i in 0..5 {
let body = create_manga(
&h.app,
&cookie,
json!({ "title": format!("Vol {i}"), "authors": ["Solo"] }),
)
.await;
if author_id.is_empty() {
author_id = first_author_id(&body);
}
}
let resp = h
.app
.oneshot(common::get(&format!(
"/api/v1/authors/{author_id}/mangas?limit=2&offset=1"
)))
.await
.unwrap();
let body = common::body_json(resp).await;
assert_eq!(body["items"].as_array().unwrap().len(), 2);
assert_eq!(body["page"]["limit"], 2);
assert_eq!(body["page"]["offset"], 1);
// Total reflects unfiltered count, not page size.
assert_eq!(body["page"]["total"], 5);
}
#[sqlx::test(migrations = "./migrations")]
async fn list_mangas_for_unknown_author_returns_empty(pool: PgPool) {
let h = common::harness(pool);
let resp = h
.app
.oneshot(common::get(&format!(
"/api/v1/authors/{}/mangas",
Uuid::new_v4()
)))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
let body = common::body_json(resp).await;
assert_eq!(body["items"], json!([]));
assert_eq!(body["page"]["total"], 0);
}
#[sqlx::test(migrations = "./migrations")]
async fn search_authors_matches_substring_case_insensitively(pool: PgPool) {
let h = common::harness(pool);
let (_, cookie) = common::register_user(&h.app).await;
for name in ["Kentaro Miura", "Eiichiro Oda", "Makoto Yukimura"] {
let _ = create_manga(
&h.app,
&cookie,
json!({ "title": format!("Book of {name}"), "authors": [name] }),
)
.await;
}
// Substring is case-insensitive (ILIKE) — "miura" picks Kentaro
// Miura but NOT Makoto Yukimura (whose surname is Yukimura, not
// "Yumiura"). The trigram path is exercised in api_mangas.rs.
let resp = h
.app
.clone()
.oneshot(common::get("/api/v1/authors?search=miura"))
.await
.unwrap();
let body = common::body_json(resp).await;
let names: Vec<&str> = body
.as_array()
.unwrap()
.iter()
.map(|a| a["name"].as_str().unwrap())
.collect();
assert_eq!(names, vec!["Kentaro Miura"]);
// "yuki" matches only Makoto Yukimura.
let resp = h
.app
.oneshot(common::get("/api/v1/authors?search=yuki"))
.await
.unwrap();
let body = common::body_json(resp).await;
let names: Vec<&str> = body
.as_array()
.unwrap()
.iter()
.map(|a| a["name"].as_str().unwrap())
.collect();
assert_eq!(names, vec!["Makoto Yukimura"]);
}
#[sqlx::test(migrations = "./migrations")]
async fn search_authors_default_limit_caps_at_10(pool: PgPool) {
let h = common::harness(pool);
let (_, cookie) = common::register_user(&h.app).await;
for i in 0..15 {
let _ = create_manga(
&h.app,
&cookie,
json!({ "title": format!("Book {i}"), "authors": [format!("Author {i}")] }),
)
.await;
}
let resp = h
.app
.oneshot(common::get("/api/v1/authors"))
.await
.unwrap();
let body = common::body_json(resp).await;
// No search term: returns the default page (10), not all 15.
assert_eq!(body.as_array().unwrap().len(), 10);
}
#[sqlx::test(migrations = "./migrations")]
async fn manga_count_drops_when_manga_deleted(pool: PgPool) {
let h = common::harness(pool.clone());
let (_, cookie) = common::register_user(&h.app).await;
let m1 = create_manga(
&h.app,
&cookie,
json!({ "title": "Vol 1", "authors": ["Solo"] }),
)
.await;
let _ = create_manga(
&h.app,
&cookie,
json!({ "title": "Vol 2", "authors": ["Solo"] }),
)
.await;
let author_id = first_author_id(&m1);
let manga_id = m1["id"].as_str().unwrap().to_string();
// No DELETE endpoint yet — delete via SQL to simulate cleanup.
sqlx::query("DELETE FROM mangas WHERE id = $1")
.bind(Uuid::parse_str(&manga_id).unwrap())
.execute(&pool)
.await
.unwrap();
let resp = h
.app
.oneshot(common::get(&format!("/api/v1/authors/{author_id}")))
.await
.unwrap();
let body = common::body_json(resp).await;
// FK cascade on manga_authors keeps the count honest.
assert_eq!(body["manga_count"], 1);
}