80ab119750
Previously a storage failure mid-chapter-upload left a partial chapter row pointing at a `page_count` that didn't match what was on disk, plus any successfully-inserted page rows. Same shape for a manga create where the cover put or cover_image_path UPDATE failed after the manga row was already inserted. Fix at the DB layer: open `pool.begin()` at the start of the create, do all DB writes against `&mut *tx`, commit only after the full sequence succeeds. If anything before commit fails, the transaction is rolled back on drop and the DB stays consistent. Bytes already written to storage on a rolled-back transaction become orphans on disk; a future reaper can sweep them, and we prioritise DB consistency over storage tidiness in this branch. - repo::manga::create / set_cover_image_path: signature changed to `impl PgExecutor<'_>` so handlers can pass either `&PgPool` or `&mut *tx`. set_cover_image_path is new — replaces the inline `UPDATE` in the manga upload handler so the call site stays consistent. - repo::chapter::create / set_page_count: same shape. - repo::page::create: same. - api::mangas::create and api::chapters::create both open a transaction around their DB writes; storage puts happen inside the transaction window (since they must precede the page-row insert), so a failed put aborts before commit. New integration test (api_uploads::chapter_upload_rolls_back_when_ storage_fails_mid_loop) uses a `FailingStorage` helper that errors on the N-th `put`. With N=1 (page 2 fails), the handler returns 500 and the chapter + page tables stay empty. `harness_with_failing_storage` is exposed alongside the existing `harness` so future tests can reuse it for other fault-injection cases. Lockstep version bump to 0.9.3. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
103 lines
2.4 KiB
Rust
103 lines
2.4 KiB
Rust
//! Chapter persistence.
|
|
|
|
use sqlx::{PgExecutor, PgPool};
|
|
use uuid::Uuid;
|
|
|
|
use crate::domain::Chapter;
|
|
use crate::error::{AppError, AppResult};
|
|
|
|
pub async fn list_for_manga(
|
|
pool: &PgPool,
|
|
manga_id: Uuid,
|
|
limit: i64,
|
|
offset: i64,
|
|
) -> AppResult<Vec<Chapter>> {
|
|
let rows = sqlx::query_as::<_, Chapter>(
|
|
r#"
|
|
SELECT id, manga_id, number, title, page_count, created_at
|
|
FROM chapters
|
|
WHERE manga_id = $1
|
|
ORDER BY number ASC
|
|
LIMIT $2 OFFSET $3
|
|
"#,
|
|
)
|
|
.bind(manga_id)
|
|
.bind(limit)
|
|
.bind(offset)
|
|
.fetch_all(pool)
|
|
.await?;
|
|
Ok(rows)
|
|
}
|
|
|
|
pub async fn find_by_manga_and_number(
|
|
pool: &PgPool,
|
|
manga_id: Uuid,
|
|
number: i32,
|
|
) -> AppResult<Option<Chapter>> {
|
|
let row = sqlx::query_as::<_, Chapter>(
|
|
r#"
|
|
SELECT id, manga_id, number, title, page_count, created_at
|
|
FROM chapters
|
|
WHERE manga_id = $1 AND number = $2
|
|
"#,
|
|
)
|
|
.bind(manga_id)
|
|
.bind(number)
|
|
.fetch_optional(pool)
|
|
.await?;
|
|
Ok(row)
|
|
}
|
|
|
|
/// Accepts any `PgExecutor` so the upload handler can run this inside a
|
|
/// transaction with the per-page inserts. Returns `AppError::Conflict`
|
|
/// on the (manga_id, number) unique violation so handlers can surface a
|
|
/// clean 409.
|
|
pub async fn create<'e, E: PgExecutor<'e>>(
|
|
executor: E,
|
|
manga_id: Uuid,
|
|
number: i32,
|
|
title: Option<&str>,
|
|
) -> AppResult<Chapter> {
|
|
let result = sqlx::query_as::<_, Chapter>(
|
|
r#"
|
|
INSERT INTO chapters (manga_id, number, title)
|
|
VALUES ($1, $2, $3)
|
|
RETURNING id, manga_id, number, title, page_count, created_at
|
|
"#,
|
|
)
|
|
.bind(manga_id)
|
|
.bind(number)
|
|
.bind(title)
|
|
.fetch_one(executor)
|
|
.await;
|
|
|
|
match result {
|
|
Ok(c) => Ok(c),
|
|
Err(e) if is_unique_violation(&e) => Err(AppError::Conflict(format!(
|
|
"chapter {number} already exists for this manga"
|
|
))),
|
|
Err(e) => Err(AppError::Database(e)),
|
|
}
|
|
}
|
|
|
|
pub async fn set_page_count<'e, E: PgExecutor<'e>>(
|
|
executor: E,
|
|
id: Uuid,
|
|
page_count: i32,
|
|
) -> AppResult<()> {
|
|
sqlx::query("UPDATE chapters SET page_count = $1 WHERE id = $2")
|
|
.bind(page_count)
|
|
.bind(id)
|
|
.execute(executor)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
fn is_unique_violation(err: &sqlx::Error) -> bool {
|
|
if let sqlx::Error::Database(db_err) = err {
|
|
db_err.code().as_deref() == Some("23505")
|
|
} else {
|
|
false
|
|
}
|
|
}
|