feat: manga metadata with status, authors, genres, tags, and search filters (0.15.0)

Adds first-class manga metadata across the stack:

- **Status** (ongoing / completed), **alternative titles**, normalized
  **multi-author** support, **curated genres** (13 seeded), and
  **free-form user tags** (case-insensitive, globally shared). Each is
  modelled as its own table joined to mangas; `mangas.author` is
  backfilled into `authors` + `manga_authors` and dropped.
- New endpoints: `PATCH /v1/mangas/:id` (three-state `description`),
  `POST/DELETE /v1/mangas/:id/tags[/:tag_id]`, `GET /v1/genres`,
  `GET /v1/tags?search=`.
- `GET /v1/mangas` now returns `MangaCard` (with authors + genres
  batched in) and supports `?status=`, `?author_id=`, `?genre_id=`,
  `?tag_id=` filters — AND across facets, with empty-array no-op
  semantics for the unnest primitive.
- `GET /v1/mangas/:id` returns the enriched `MangaDetail` with tags.
- Frontend: reusable `Chip` component; manga detail page renders
  authors as chips linking to `/authors/:id` (Phase 2), a status
  badge, alt titles, genres, and tags with inline add/remove (only
  the attacher sees remove); upload form supports multi-author /
  multi-genre / alt titles / status; search page gets a collapsible
  URL-synced filter panel with keyboard-navigable tag autocomplete.
- 126 backend tests (incl. AND-across-facets primitive, case-insens
  author/tag de-dup, transactional create rollback, PATCH semantics
  for missing / null / set on description); 72 frontend tests +
  svelte-check clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

backend/src/repo/manga.rs

@@ -6,11 +6,17 @@
 //! a trait + impl if a second backend ever becomes necessary.
 
 use serde::Deserialize;
-use sqlx::{PgExecutor, PgPool};
+use sqlx::{PgConnection, PgExecutor, PgPool};
 use uuid::Uuid;
 
-use crate::domain::manga::{Manga, NewManga};
+use crate::domain::manga::{Manga, MangaCard, MangaDetail};
 use crate::error::{AppError, AppResult};
+use crate::repo;
+
+/// Status values mirror the CHECK constraint in 0009. Centralized so
+/// the API layer can validate uploads against the same vocabulary.
+pub const STATUSES: &[&str] = &["ongoing", "completed"];
+pub const DEFAULT_STATUS: &str = "ongoing";
 
 #[derive(Debug, Clone, Copy, Default, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -22,28 +28,65 @@ pub enum ListSort {
     Title,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct ListQuery {
     pub search: Option<String>,
+    pub status: Option<String>,
+    pub author_ids: Vec<Uuid>,
+    pub genre_ids: Vec<Uuid>,
+    pub tag_ids: Vec<Uuid>,
     pub limit: i64,
     pub offset: i64,
     pub sort: ListSort,
 }
 
-impl Default for ListQuery {
-    fn default() -> Self {
-        Self {
-            search: None,
-            limit: 50,
-            offset: 0,
-            sort: ListSort::Recent,
-        }
-    }
-}
+const SELECT_COLS: &str =
+    "id, title, status, alt_titles, description, cover_image_path, created_at, updated_at";
+
+/// Shared WHERE used by both the rows and the count queries. Filters
+/// are AND across facets: every supplied author_id (or genre, or tag)
+/// must be attached to the manga for it to match. Empty arrays mean
+/// "no filter" because `NOT EXISTS` over an empty unnest is vacuously
+/// true.
+const FILTER_WHERE: &str = r#"
+    ($1::text IS NULL
+     OR title ILIKE '%' || $1 || '%'
+     OR title % $1
+     OR EXISTS (
+            SELECT 1 FROM manga_authors ma
+              JOIN authors a ON a.id = ma.author_id
+             WHERE ma.manga_id = mangas.id
+               AND (a.name ILIKE '%' || $1 || '%' OR a.name % $1)
+        )
+    )
+    AND ($2::text IS NULL OR status = $2)
+    AND NOT EXISTS (
+        SELECT 1 FROM unnest($3::uuid[]) AS req(id)
+         WHERE NOT EXISTS (
+                SELECT 1 FROM manga_authors ma
+                 WHERE ma.manga_id = mangas.id AND ma.author_id = req.id
+             )
+    )
+    AND NOT EXISTS (
+        SELECT 1 FROM unnest($4::uuid[]) AS req(id)
+         WHERE NOT EXISTS (
+                SELECT 1 FROM manga_genres mg
+                 WHERE mg.manga_id = mangas.id AND mg.genre_id = req.id
+             )
+    )
+    AND NOT EXISTS (
+        SELECT 1 FROM unnest($5::uuid[]) AS req(id)
+         WHERE NOT EXISTS (
+                SELECT 1 FROM manga_tags mt
+                 WHERE mt.manga_id = mangas.id AND mt.tag_id = req.id
+             )
+    )
+"#;
 
 /// Returns the page of mangas matching `query` plus the unfiltered total
-/// count for the same filter. The trigram GIN indexes (see 0005_search.sql)
-/// keep both queries cheap as the library grows.
+/// count for the same filter. The trigram GIN indexes (see 0005_search.sql
+/// and 0009_manga_metadata.sql) keep both queries cheap as the library
+/// grows.
 pub async fn list(pool: &PgPool, query: &ListQuery) -> AppResult<(Vec<Manga>, i64)> {
     // `order_by` is interpolated from a hard-coded enum, never from request
     // input, so this is not a SQL injection seam.
@@ -53,80 +96,152 @@ pub async fn list(pool: &PgPool, query: &ListQuery) -> AppResult<(Vec<Manga>, i6
     };
 
     let search = query.search.as_deref();
+    let status = query.status.as_deref();
 
     let list_sql = format!(
         r#"
-        SELECT id, title, author, description, cover_image_path, created_at, updated_at
+        SELECT {SELECT_COLS}
         FROM mangas
-        WHERE $1::text IS NULL
-           OR title ILIKE '%' || $1 || '%'
-           OR COALESCE(author, '') ILIKE '%' || $1 || '%'
-           OR title % $1
-           OR (author IS NOT NULL AND author % $1)
+        WHERE {FILTER_WHERE}
         ORDER BY {order_by}
-        LIMIT $2 OFFSET $3
+        LIMIT $6 OFFSET $7
         "#
     );
 
     let rows = sqlx::query_as::<_, Manga>(&list_sql)
         .bind(search)
+        .bind(status)
+        .bind(&query.author_ids)
+        .bind(&query.genre_ids)
+        .bind(&query.tag_ids)
         .bind(query.limit)
         .bind(query.offset)
         .fetch_all(pool)
         .await?;
 
-    let count_sql = r#"
+    let count_sql = format!(
+        r#"
         SELECT count(*) FROM mangas
-        WHERE $1::text IS NULL
-           OR title ILIKE '%' || $1 || '%'
-           OR COALESCE(author, '') ILIKE '%' || $1 || '%'
-           OR title % $1
-           OR (author IS NOT NULL AND author % $1)
-    "#;
-    let (total,): (i64,) = sqlx::query_as(count_sql)
+        WHERE {FILTER_WHERE}
+        "#
+    );
+    let (total,): (i64,) = sqlx::query_as(&count_sql)
         .bind(search)
+        .bind(status)
+        .bind(&query.author_ids)
+        .bind(&query.genre_ids)
+        .bind(&query.tag_ids)
         .fetch_one(pool)
         .await?;
 
     Ok((rows, total))
 }
 
+/// Same filter as `list`, but wraps each row with its authors + genres
+/// in a single batched round-trip. Tags are intentionally not loaded
+/// here — see `MangaCard` in the domain layer.
+pub async fn list_cards(
+    pool: &PgPool,
+    query: &ListQuery,
+) -> AppResult<(Vec<MangaCard>, i64)> {
+    let (rows, total) = list(pool, query).await?;
+    let ids: Vec<Uuid> = rows.iter().map(|m| m.id).collect();
+    let mut authors = repo::author::load_for_mangas(pool, &ids).await?;
+    let mut genres = repo::genre::load_for_mangas(pool, &ids).await?;
+    let cards = rows
+        .into_iter()
+        .map(|manga| MangaCard {
+            authors: authors.remove(&manga.id).unwrap_or_default(),
+            genres: genres.remove(&manga.id).unwrap_or_default(),
+            manga,
+        })
+        .collect();
+    Ok((cards, total))
+}
+
 pub async fn get(pool: &PgPool, id: Uuid) -> AppResult<Manga> {
-    sqlx::query_as::<_, Manga>(
-        r#"
-        SELECT id, title, author, description, cover_image_path, created_at, updated_at
-        FROM mangas
-        WHERE id = $1
-        "#,
-    )
+    sqlx::query_as::<_, Manga>(&format!(
+        "SELECT {SELECT_COLS} FROM mangas WHERE id = $1"
+    ))
     .bind(id)
     .fetch_optional(pool)
     .await?
     .ok_or(AppError::NotFound)
 }
 
-/// Accepts any `PgExecutor` so callers can pass `&PgPool` for simple
-/// inserts or `&mut *tx` to run inside a transaction. Same applies to
-/// `set_cover_image_path` below.
+pub async fn get_detail(pool: &PgPool, id: Uuid) -> AppResult<MangaDetail> {
+    let manga = get(pool, id).await?;
+    let authors = repo::author::list_for_manga(pool, id).await?;
+    let genres = repo::genre::list_for_manga(pool, id).await?;
+    let tags = repo::tag::list_for_manga(pool, id).await?;
+    Ok(MangaDetail { manga, authors, genres, tags })
+}
+
+/// Insert just the manga row. Relations (authors, genres) are written
+/// by the caller via `repo::author::set_for_manga` etc. in the same
+/// transaction. `status` is taken as a validated string — the handler
+/// is responsible for defaulting/validating it.
 pub async fn create<'e, E: PgExecutor<'e>>(
     executor: E,
-    input: NewManga,
+    title: &str,
+    status: &str,
+    description: Option<&str>,
+    alt_titles: &[String],
 ) -> AppResult<Manga> {
-    let row = sqlx::query_as::<_, Manga>(
+    let row = sqlx::query_as::<_, Manga>(&format!(
         r#"
-        INSERT INTO mangas (title, author, description)
-        VALUES ($1, $2, $3)
-        RETURNING id, title, author, description, cover_image_path, created_at, updated_at
-        "#,
-    )
-    .bind(&input.title)
-    .bind(&input.author)
-    .bind(&input.description)
+        INSERT INTO mangas (title, status, description, alt_titles)
+        VALUES ($1, $2, $3, $4)
+        RETURNING {SELECT_COLS}
+        "#
+    ))
+    .bind(title)
+    .bind(status)
+    .bind(description)
+    .bind(alt_titles)
     .fetch_one(executor)
     .await?;
     Ok(row)
 }
 
+/// Patch the inline columns. Each `Option` argument leaves the field
+/// untouched when `None`. `description` uses two binds — a `provided`
+/// boolean and the new value — so callers can distinguish "leave
+/// alone" from "set to NULL" (both look the same in a plain
+/// `Option<&str>` because serde collapses missing and explicit-null).
+pub async fn update_basics(
+    conn: &mut PgConnection,
+    id: Uuid,
+    title: Option<&str>,
+    status: Option<&str>,
+    description_provided: bool,
+    description: Option<&str>,
+    alt_titles: Option<&[String]>,
+) -> AppResult<Manga> {
+    let row = sqlx::query_as::<_, Manga>(&format!(
+        r#"
+        UPDATE mangas
+           SET title       = COALESCE($2, title),
+               status      = COALESCE($3, status),
+               description = CASE WHEN $4::boolean THEN $5 ELSE description END,
+               alt_titles  = COALESCE($6, alt_titles),
+               updated_at  = now()
+         WHERE id = $1
+        RETURNING {SELECT_COLS}
+        "#
+    ))
+    .bind(id)
+    .bind(title)
+    .bind(status)
+    .bind(description_provided)
+    .bind(description)
+    .bind(alt_titles)
+    .fetch_optional(&mut *conn)
+    .await?
+    .ok_or(AppError::NotFound)?;
+    Ok(row)
+}
+
 pub async fn set_cover_image_path<'e, E: PgExecutor<'e>>(
     executor: E,
     id: Uuid,
@@ -139,3 +254,12 @@ pub async fn set_cover_image_path<'e, E: PgExecutor<'e>>(
         .await?;
     Ok(())
 }
+
+pub async fn exists(pool: &PgPool, id: Uuid) -> AppResult<bool> {
+    let (exists,): (bool,) =
+        sqlx::query_as("SELECT EXISTS(SELECT 1 FROM mangas WHERE id = $1)")
+            .bind(id)
+            .fetch_one(pool)
+            .await?;
+    Ok(exists)
+}