WIP

calibre-db/src/data/book.rs

@@ -1,13 +1,11 @@
 //! Book data.
 
-use rusqlite::{named_params, Connection, Row};
+use rusqlite::{Connection, Row, named_params};
 use serde::Serialize;
 use time::OffsetDateTime;
 
-use super::{
-    error::DataStoreError,
-    pagination::{Pagination, SortOrder},
-};
+use super::pagination::{HasPrevOrMoreError, Pagination, PaginationError, SortOrder};
+use snafu::{ResultExt, Snafu};
 
 /// Book in calibre.
 #[derive(Debug, Clone, Serialize)]
@@ -28,6 +26,54 @@ pub struct Book {
     pub description: Option<String>,
 }
 
+#[derive(Debug, Snafu)]
+#[snafu(display("Failed to fetch multiple books."))]
+pub struct MultipleBooksError {
+    source: PaginationError,
+}
+
+#[derive(Debug, Snafu)]
+#[snafu(display("Failed to fetch author's books."))]
+pub struct AuthorBooksError {
+    source: PaginationError,
+}
+
+#[derive(Debug, Snafu)]
+pub enum SeriesBookError {
+    #[snafu(display("Failed to prepare statement."))]
+    PrepareSeriesBook { source: rusqlite::Error },
+    #[snafu(display("Failed to execute statement."))]
+    ExecuteSeriesBook { source: rusqlite::Error },
+}
+
+#[derive(Debug, Snafu)]
+pub enum RecentBooksError {
+    #[snafu(display("Failed to prepare statement."))]
+    PrepareRecentBooks { source: rusqlite::Error },
+    #[snafu(display("Failed to execute statement."))]
+    ExecuteRecentBooks { source: rusqlite::Error },
+}
+
+#[derive(Debug, Snafu)]
+pub enum ScalarBookError {
+    #[snafu(display("Failed to prepare statement."))]
+    PrepareScalarBook { source: rusqlite::Error },
+    #[snafu(display("Failed to execute statement."))]
+    ExecuteScalarBook { source: rusqlite::Error },
+}
+
+#[derive(Debug, Snafu)]
+#[snafu(display("Failed to check for previous books."))]
+pub struct PreviousBooksError {
+    source: HasPrevOrMoreError,
+}
+
+#[derive(Debug, Snafu)]
+#[snafu(display("Failed to check for more books."))]
+pub struct MoreBooksError {
+    source: HasPrevOrMoreError,
+}
+
 impl Book {
     fn from_row(row: &Row<'_>) -> Result<Self, rusqlite::Error> {
         Ok(Self {
@@ -48,7 +94,7 @@ impl Book {
         limit: u64,
         cursor: Option<&str>,
         sort_order: &SortOrder,
-    ) -> Result<Vec<Self>, DataStoreError> {
+    ) -> Result<Vec<Self>, MultipleBooksError> {
         let pagination = Pagination::new("sort", cursor, limit, *sort_order);
         pagination.paginate(
             conn,
@@ -56,7 +102,7 @@ impl Book {
                 FROM books LEFT JOIN comments ON books.id = comments.book",
             &[],
             Self::from_row,
-        )
+        ).context(MultipleBooksSnafu)
     }
 
     /// Fetch books for an author specified by `author_id`, paginate the books by starting at `cursor`,
@@ -67,7 +113,7 @@ impl Book {
         limit: u64,
         cursor: Option<&str>,
         sort_order: SortOrder,
-    ) -> Result<Vec<Self>, DataStoreError> {
+    ) -> Result<Vec<Self>, AuthorBooksError> {
         let pagination = Pagination::new("books.sort", cursor, limit, sort_order);
         pagination.paginate(
             conn,
@@ -77,11 +123,11 @@ impl Book {
                 WHERE books_authors_link.author = (:author_id) AND",
             &[(":author_id", &author_id)],
             Self::from_row,
-        )
+        ).context(AuthorBooksSnafu)
     }
 
     /// Get all books belonging to the series with id `id`.
-    pub fn series_books(conn: &Connection, id: u64) -> Result<Vec<Book>, DataStoreError> {
+    pub fn series_books(conn: &Connection, id: u64) -> Result<Vec<Book>, SeriesBookError> {
         let mut stmt = conn.prepare(
             "SELECT books.id, books.title, books.sort, books.path, books.uuid, books.last_modified, comments.text FROM series \
                 INNER JOIN books_series_link ON series.id = books_series_link.series \
@@ -89,40 +135,50 @@ impl Book {
                 LEFT JOIN comments ON books.id = comments.book \
                 WHERE books_series_link.series = (:id) \
                 ORDER BY books.series_index",
-        )?;
+        ).context(PrepareSeriesBookSnafu)?;
         let params = named_params! { ":id": id };
-        let iter = stmt.query_map(params, Self::from_row)?;
+        let iter = stmt
+            .query_map(params, Self::from_row)
+            .context(ExecuteSeriesBookSnafu)?;
         Ok(iter.filter_map(Result::ok).collect())
     }
 
     /// Get recent books up to a limit of `limit`.
-    pub fn recents(conn: &Connection, limit: u64) -> Result<Vec<Self>, DataStoreError> {
+    pub fn recents(conn: &Connection, limit: u64) -> Result<Vec<Self>, RecentBooksError> {
         let mut stmt = conn.prepare(
             "SELECT books.id, books.title, books.sort, books.path, books.uuid, books.last_modified, comments.text \
                 FROM books LEFT JOIN comments ON books.id = comments.book ORDER BY books.timestamp DESC LIMIT (:limit)"
-        )?;
+        ).context(PrepareRecentBooksSnafu)?;
         let params = named_params! { ":limit": limit };
-        let iter = stmt.query_map(params, Self::from_row)?;
+        let iter = stmt
+            .query_map(params, Self::from_row)
+            .context(ExecuteRecentBooksSnafu)?;
         Ok(iter.filter_map(Result::ok).collect())
     }
 
     /// Get a single book, specified `id`.
-    pub fn scalar_book(conn: &Connection, id: u64) -> Result<Self, DataStoreError> {
+    pub fn scalar_book(conn: &Connection, id: u64) -> Result<Self, ScalarBookError> {
         let mut stmt = conn.prepare(
             "SELECT books.id, books.title, books.sort, books.path, books.uuid, books.last_modified, comments.text \
                 FROM books LEFT JOIN comments WHERE books.id = (:id)",
-        )?;
+        ).context(PrepareScalarBookSnafu)?;
         let params = named_params! { ":id": id };
-        Ok(stmt.query_row(params, Self::from_row)?)
+        stmt.query_row(params, Self::from_row)
+            .context(ExecuteScalarBookSnafu)
     }
 
     /// Check if there are more books before the specified cursor.
-    pub fn has_previous_books(conn: &Connection, sort_title: &str) -> Result<bool, DataStoreError> {
+    pub fn has_previous_books(
+        conn: &Connection,
+        sort_title: &str,
+    ) -> Result<bool, PreviousBooksError> {
         Pagination::has_prev_or_more(conn, "books", sort_title, &SortOrder::DESC)
+            .context(PreviousBooksSnafu)
     }
 
     /// Check if there are more books after the specified cursor.
-    pub fn has_more_books(conn: &Connection, sort_title: &str) -> Result<bool, DataStoreError> {
+    pub fn has_more_books(conn: &Connection, sort_title: &str) -> Result<bool, MoreBooksError> {
         Pagination::has_prev_or_more(conn, "books", sort_title, &SortOrder::ASC)
+            .context(MoreBooksSnafu)
     }
 }