chore: initial project scaffold

Set up Mangalord with a Rust/axum backend, SvelteKit frontend, Postgres,
and Docker Compose deployment. Establishes the architecture and TDD
patterns the project will extend:

- Hexagonal-ish backend layering (domain / repo / storage / api) with
  a pluggable Storage trait (LocalStorage today, S3 as a future impl).
- Initial migration: users, mangas, chapters, bookmarks.
- Vertical slice for mangas (list, search, create, get) with
  #[sqlx::test] integration coverage and storage unit tests.
- SvelteKit frontend using Svelte 5 runes, typed API client, Vitest
  unit tests and Playwright e2e with route mocking.
- CLAUDE.md documenting layering, TDD/git/SemVer workflow rules, and
  extension points (tags, fulltext search, OCR, S3, auth).
- Project-scoped .claude/settings.json with permission allowlist for
  the toolchain (git, cargo, npm/vite, docker, psql, gh, doc fetches).

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

backend/tests/api_mangas.rs

@@ -0,0 +1,77 @@
+mod common;
+
+use axum::http::StatusCode;
+use serde_json::json;
+use sqlx::PgPool;
+use tower::ServiceExt;
+
+#[sqlx::test(migrations = "./migrations")]
+async fn list_is_empty_initially(pool: PgPool) {
+    let h = common::harness(pool);
+    let resp = h.app.oneshot(common::get("/api/mangas")).await.unwrap();
+    assert_eq!(resp.status(), StatusCode::OK);
+    assert_eq!(common::body_json(resp).await, json!([]));
+}
+
+#[sqlx::test(migrations = "./migrations")]
+async fn create_then_list_roundtrip(pool: PgPool) {
+    let h = common::harness(pool);
+
+    let created = h.app.clone().oneshot(common::post_json(
+        "/api/mangas",
+        json!({ "title": "Berserk", "author": "Kentaro Miura", "description": null }),
+    )).await.unwrap();
+    assert_eq!(created.status(), StatusCode::OK);
+    let body = common::body_json(created).await;
+    assert_eq!(body["title"], "Berserk");
+    assert_eq!(body["author"], "Kentaro Miura");
+    assert!(body["id"].as_str().is_some());
+
+    let listed = h.app.oneshot(common::get("/api/mangas")).await.unwrap();
+    let listed_body = common::body_json(listed).await;
+    assert_eq!(listed_body.as_array().unwrap().len(), 1);
+    assert_eq!(listed_body[0]["title"], "Berserk");
+}
+
+#[sqlx::test(migrations = "./migrations")]
+async fn search_filters_by_title_and_author(pool: PgPool) {
+    let h = common::harness(pool);
+
+    for (title, author) in [
+        ("One Piece", "Eiichiro Oda"),
+        ("Berserk", "Kentaro Miura"),
+        ("Vinland Saga", "Makoto Yukimura"),
+    ] {
+        let _ = h.app.clone().oneshot(common::post_json(
+            "/api/mangas",
+            json!({ "title": title, "author": author }),
+        )).await.unwrap();
+    }
+
+    let resp = h.app.clone().oneshot(common::get("/api/mangas?search=miura")).await.unwrap();
+    let body = common::body_json(resp).await;
+    let titles: Vec<&str> = body.as_array().unwrap().iter().map(|m| m["title"].as_str().unwrap()).collect();
+    assert_eq!(titles, vec!["Berserk"]);
+
+    let resp = h.app.oneshot(common::get("/api/mangas?search=saga")).await.unwrap();
+    let body = common::body_json(resp).await;
+    let titles: Vec<&str> = body.as_array().unwrap().iter().map(|m| m["title"].as_str().unwrap()).collect();
+    assert_eq!(titles, vec!["Vinland Saga"]);
+}
+
+#[sqlx::test(migrations = "./migrations")]
+async fn create_rejects_empty_title(pool: PgPool) {
+    let h = common::harness(pool);
+    let resp = h.app.oneshot(common::post_json(
+        "/api/mangas",
+        json!({ "title": "   ", "author": null }),
+    )).await.unwrap();
+    assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+}
+
+#[sqlx::test(migrations = "./migrations")]
+async fn get_unknown_id_is_404(pool: PgPool) {
+    let h = common::harness(pool);
+    let resp = h.app.oneshot(common::get("/api/mangas/00000000-0000-0000-0000-000000000000")).await.unwrap();
+    assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+}

backend/tests/common/mod.rs

@@ -0,0 +1,44 @@
+use std::sync::Arc;
+
+use axum::body::Body;
+use axum::http::Request;
+use axum::Router;
+use http_body_util::BodyExt;
+use sqlx::PgPool;
+use tempfile::TempDir;
+
+use mangalord::app::{router, AppState};
+use mangalord::storage::LocalStorage;
+
+pub struct Harness {
+    pub app: Router,
+    // Kept alive for the lifetime of the test so the temp dir is not dropped.
+    pub _storage_dir: TempDir,
+}
+
+pub fn harness(pool: PgPool) -> Harness {
+    let storage_dir = tempfile::tempdir().expect("tempdir");
+    let state = AppState {
+        db: pool,
+        storage: Arc::new(LocalStorage::new(storage_dir.path())),
+    };
+    Harness { app: router(state), _storage_dir: storage_dir }
+}
+
+pub async fn body_json(response: axum::response::Response) -> serde_json::Value {
+    let bytes = response.into_body().collect().await.unwrap().to_bytes();
+    serde_json::from_slice(&bytes).expect("body is JSON")
+}
+
+pub fn get(uri: &str) -> Request<Body> {
+    Request::builder().uri(uri).body(Body::empty()).unwrap()
+}
+
+pub fn post_json(uri: &str, body: serde_json::Value) -> Request<Body> {
+    Request::builder()
+        .method("POST")
+        .uri(uri)
+        .header("content-type", "application/json")
+        .body(Body::from(body.to_string()))
+        .unwrap()
+}

backend/tests/health.rs

@@ -0,0 +1,14 @@
+mod common;
+
+use axum::http::StatusCode;
+use sqlx::PgPool;
+use tower::ServiceExt;
+
+#[sqlx::test(migrations = "./migrations")]
+async fn health_returns_ok(pool: PgPool) {
+    let h = common::harness(pool);
+    let resp = h.app.oneshot(common::get("/api/health")).await.unwrap();
+    assert_eq!(resp.status(), StatusCode::OK);
+    let body = common::body_json(resp).await;
+    assert_eq!(body["status"], "ok");
+}