perf: Authors page at scale — has_cover, O(n) counts, virtualized list (#122)

* feat(libcalibre): one-pass author book counts

Add Library::author_book_counts: a single GROUP BY over
books_authors_link returning a HashMap<AuthorId, i64> (authors with no
linked books are absent). Mirrors the list_series/SeriesSummary
precedent and measures 0.25ms median for 617 authors / 5,000 links in
the bench example, which gains an author_book_counts scenario.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* perf(tauri): trust has_cover; put book_count on LibraryAuthor

book_cover_image statted cover.jpg per book (PathBuf::exists), which
dominated clb_query_list_all_books at 5k books (~90% of 340ms vs 33ms
of hydration). Trust the books.has_cover flag instead — Calibre keeps
it accurate and our own cover writes (Library::set_book_cover,
Library::add_book) set it alongside writing the file. A stale flag now
yields a dangling asset URL that the frontend cover onerror fallback
absorbs. Applies to clb_query_list_all_books, clb_query_search_books,
and clb_query_books alike (shared to_library_book path).

LibraryAuthor gains book_count (u32), populated from
Library::author_book_counts everywhere the DTO is built — the authors
listing, and each book's author_list (one extra ~0.3ms map fetch per
query call) — so the Authors page no longer needs the whole book list
to render counts. bindings.ts hand-edited in specta style (field order
matches the Rust struct; LibraryBook/LibraryAuthor shapes otherwise
unchanged).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* perf(authors): backend counts + virtualized rows, drop useAllBooks

The Authors page computed each row's book count by scanning all books
per author (O(authors x books): ~480ms warm render at 617 authors /
5,000 books) and pulled the entire library via useAllBooks just for
counts and the authors-without-books filter — triggering the 340ms
list-all on page load. Both now ride on LibraryAuthor.book_count from
the authors payload; the page no longer touches the book list at all.

invalidateBooks reloads authors in the background so counts stay fresh
after book mutations (the page previously got this for free from the
stale-books reload).

The 617 author rows are also windowed with @tanstack/react-virtual
(same pattern as BookGrid), against the app's shared scroll region so
the sticky filter bar, column header, and footer behave exactly as
before.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: phildenhoff

crates/libcalibre/examples/bench_library_queries.rs

@@ -485,6 +485,15 @@ fn run() -> Result<(), String> {
         let authors = library.authors().expect("authors()");
         format!("{} rows", authors.len())
     }));
+    results.push(bench(
+        "author_book_counts() [Authors page counts, one GROUP BY]",
+        runs,
+        warmup,
+        || {
+            let counts = library.author_book_counts().expect("author_book_counts()");
+            format!("{} authors with books", counts.len())
+        },
+    ));
 
     // ---- Report ----------------------------------------------------------
     println!("\n## Benchmark results ({runs} runs after {warmup} warmup, ms)\n");

crates/libcalibre/src/library.rs

@@ -511,6 +511,13 @@ impl Library {
         operations::authors::all(&mut self.conn)
     }
 
+    /// Linked-book count per author, computed in one GROUP BY pass over
+    /// `books_authors_link` (no per-author scans). Authors with no linked
+    /// books are absent from the map — treat a missing entry as 0.
+    pub fn author_book_counts(&mut self) -> Result<HashMap<AuthorId, i64>, CalibreError> {
+        author_queries::book_counts(&mut self.conn)
+    }
+
     pub fn get_author(&mut self, author_id: AuthorId) -> Result<Author, CalibreError> {
         operations::authors::get(&mut self.conn, author_id)
     }

crates/libcalibre/src/queries/authors.rs

@@ -69,6 +69,28 @@ pub(crate) fn all(conn: &mut SqliteConnection) -> Result<Vec<Author>, CalibreErr
         .map_err(CalibreError::from)
 }
 
+/// Linked-book count per author, in one GROUP BY pass over
+/// `books_authors_link`. Authors with no linked books are absent from the
+/// map (their count is 0).
+pub(crate) fn book_counts(
+    conn: &mut SqliteConnection,
+) -> Result<HashMap<AuthorId, i64>, CalibreError> {
+    use diesel::dsl::count_star;
+
+    use crate::schema::books_authors_link::dsl::*;
+
+    let rows: Vec<(i32, i64)> = books_authors_link
+        .group_by(author)
+        .select((author, count_star()))
+        .load(conn)
+        .map_err(CalibreError::from)?;
+
+    Ok(rows
+        .into_iter()
+        .map(|(author_id, book_count)| (AuthorId(author_id), book_count))
+        .collect())
+}
+
 pub(crate) fn create(
     conn: &mut SqliteConnection,
     new_author: NewAuthor,

crates/libcalibre/tests/authors_api_test.rs

@@ -154,3 +154,53 @@ fn test_delete_author_with_books_fails() {
     let result = lib.remove_author(author.id);
     assert!(result.is_err());
 }
+
+#[test]
+fn test_author_book_counts_empty_library() {
+    let (_temp, mut lib) = setup_with_library();
+
+    let counts = lib.author_book_counts().unwrap();
+    assert!(counts.is_empty());
+}
+
+#[test]
+fn test_author_book_counts_groups_links_per_author() {
+    let (_temp, mut lib) = setup_with_library();
+
+    let bookless_author_id = lib
+        .add_author(AuthorAdd {
+            name: "No Books".to_string(),
+            sort: Some("Books, No".to_string()),
+            link: None,
+        })
+        .unwrap();
+
+    let book = |title: &str, author_names: Vec<&str>| BookAdd {
+        title: title.to_string(),
+        author_names: author_names.into_iter().map(String::from).collect(),
+        tags: None,
+        series: None,
+        series_index: None,
+        publisher: None,
+        publication_date: None,
+        rating: None,
+        comments: None,
+        identifiers: HashMap::new(),
+        file_paths: vec![],
+    };
+
+    lib.add_book(book("Solo Work", vec!["Author A"])).unwrap();
+    lib.add_book(book("Another Solo Work", vec!["Author A"]))
+        .unwrap();
+    lib.add_book(book("Co-Written Work", vec!["Author A", "Author B"]))
+        .unwrap();
+
+    let authors = lib.authors().unwrap();
+    let id_of = |name: &str| authors.iter().find(|a| a.name == name).unwrap().id;
+
+    let counts = lib.author_book_counts().unwrap();
+    assert_eq!(counts.get(&id_of("Author A")), Some(&3));
+    assert_eq!(counts.get(&id_of("Author B")), Some(&1));
+    // Authors with no linked books are absent, not present-with-zero.
+    assert!(!counts.contains_key(&bookless_author_id));
+}

src-tauri/src/book.rs

@@ -59,12 +59,20 @@ pub struct LibraryBook {
 }
 
 impl LibraryBook {
-    pub fn from_library_book(book: &libcalibre::library::Book, library_path: &str) -> Self {
+    pub fn from_library_book(
+        book: &libcalibre::library::Book,
+        library_path: &str,
+        author_book_counts: &HashMap<libcalibre::AuthorId, i64>,
+    ) -> Self {
         Self {
             id: book.id.as_i32().to_string(),
             uuid: Some(book.uuid.clone()),
             title: book.title.clone(),
-            author_list: book.authors.iter().map(LibraryAuthor::from).collect(),
+            author_list: book
+                .authors
+                .iter()
+                .map(|author| LibraryAuthor::from_author(author, author_book_counts))
+                .collect(),
             tag_list: book.tags.clone(),
             sortable_title: book.sortable_title.clone(),
             identifier_list: book.identifiers.iter().map(Identifier::from).collect(),
@@ -97,6 +105,11 @@ pub struct LibraryAuthor {
     pub id: String,
     pub name: String,
     pub sortable_name: String,
+    /// Number of books in the library linked to this author, from
+    /// `Library::author_book_counts` (one GROUP BY pass over
+    /// `books_authors_link`). The Authors page renders this directly
+    /// instead of deriving counts from the whole book list.
+    pub book_count: u32,
 }
 
 #[derive(Serialize, Deserialize, specta::Type)]

src-tauri/src/libs/calibre/author.rs

@@ -1,13 +1,26 @@
+use std::collections::HashMap;
+
 use serde::{Deserialize, Serialize};
 
 use crate::book::LibraryAuthor;
 
-impl From<&libcalibre::library::Author> for LibraryAuthor {
-    fn from(author: &libcalibre::library::Author) -> Self {
+impl LibraryAuthor {
+    /// Build the DTO from a hydrated author plus the library-wide
+    /// `Library::author_book_counts` map (authors absent from the map have
+    /// no linked books).
+    pub fn from_author(
+        author: &libcalibre::library::Author,
+        book_counts: &HashMap<libcalibre::AuthorId, i64>,
+    ) -> Self {
         LibraryAuthor {
             id: author.id.as_i32().to_string(),
             name: author.name.clone(),
             sortable_name: author.sort.clone(),
+            book_count: book_counts
+                .get(&author.id)
+                .copied()
+                .map(|count| u32::try_from(count).unwrap_or(u32::MAX))
+                .unwrap_or(0),
         }
     }
 }

src-tauri/src/libs/calibre/book.rs

@@ -1,14 +1,21 @@
-use std::path::PathBuf;
+use std::{collections::HashMap, path::PathBuf};
 
-use libcalibre::Library;
+use libcalibre::{AuthorId, Library};
 
 use crate::{
     book::{LibraryBook, LocalOrRemote, LocalOrRemoteUrl},
     libs::util,
 };
 
-/// Generate a LocalOrRemoteUrl for the cover image of a book, if the file exists
-/// on disk.
+/// Generate a LocalOrRemoteUrl for the cover image of a book.
+///
+/// Trusts the `has_cover` flag from the books table (Calibre keeps it
+/// accurate, and our own cover writes — `Library::set_book_cover` and
+/// `Library::add_book` — set it alongside writing cover.jpg) instead of
+/// statting cover.jpg per book: at 5k books the per-book
+/// `PathBuf::exists` dominated `clb_query_list_all_books` (~90% of 340ms).
+/// If the flag is stale (file deleted behind Calibre's back) the URL
+/// dangles and the frontend's cover `onerror` fallback takes over.
 fn book_cover_image(
     library_root: &str,
     book: &libcalibre::library::Book,
@@ -19,22 +26,21 @@ fn book_cover_image(
 
     let cover_relative_path = format!("{}/cover.jpg", &book.book_dir_path);
     let cover_image_path = PathBuf::from(library_root).join(&cover_relative_path);
+    let url = util::path_to_asset_url(&cover_image_path);
 
-    if cover_image_path.exists() {
-        let url = util::path_to_asset_url(&cover_image_path);
-
-        Some(LocalOrRemoteUrl {
-            kind: LocalOrRemote::Local,
-            local_path: Some(cover_image_path),
-            url,
-        })
-    } else {
-        None
-    }
+    Some(LocalOrRemoteUrl {
+        kind: LocalOrRemote::Local,
+        local_path: Some(cover_image_path),
+        url,
+    })
 }
 
-fn to_library_book(library_root: &str, book: &libcalibre::library::Book) -> LibraryBook {
-    let mut library_book = LibraryBook::from_library_book(book, library_root);
+fn to_library_book(
+    library_root: &str,
+    book: &libcalibre::library::Book,
+    author_book_counts: &HashMap<AuthorId, i64>,
+) -> LibraryBook {
+    let mut library_book = LibraryBook::from_library_book(book, library_root, author_book_counts);
     library_book.cover_image = book_cover_image(library_root, book);
     library_book
 }
@@ -44,10 +50,11 @@ pub fn list_all(
     lib: &mut Library,
 ) -> Result<Vec<LibraryBook>, libcalibre::CalibreError> {
     let results = lib.books()?;
+    let author_book_counts = lib.author_book_counts()?;
 
     Ok(results
         .iter()
-        .map(|book| to_library_book(&library_root, book))
+        .map(|book| to_library_book(&library_root, book, &author_book_counts))
         .collect())
 }
 
@@ -57,10 +64,11 @@ pub fn search(
     query: &str,
 ) -> Result<Vec<LibraryBook>, libcalibre::CalibreError> {
     let results = lib.search_books(query)?;
+    let author_book_counts = lib.author_book_counts()?;
 
     Ok(results
         .iter()
-        .map(|book| to_library_book(&library_root, book))
+        .map(|book| to_library_book(&library_root, book, &author_book_counts))
         .collect())
 }
 
@@ -70,12 +78,58 @@ pub fn query_page(
     query: libcalibre::BookQuery,
 ) -> Result<(Vec<LibraryBook>, i64), libcalibre::CalibreError> {
     let page = lib.query_books(query)?;
+    let author_book_counts = lib.author_book_counts()?;
 
     Ok((
         page.items
             .iter()
-            .map(|book| to_library_book(&library_root, book))
+            .map(|book| to_library_book(&library_root, book, &author_book_counts))
             .collect(),
         page.total,
     ))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn test_book(has_cover: bool) -> libcalibre::library::Book {
+        libcalibre::library::Book {
+            id: libcalibre::BookId::from(1),
+            uuid: "test-uuid".to_string(),
+            title: "Title".to_string(),
+            sortable_title: None,
+            authors: vec![],
+            tags: vec![],
+            series: None,
+            series_index: None,
+            description: None,
+            identifiers: vec![],
+            has_cover,
+            is_read: false,
+            files: vec![],
+            created_at: chrono::DateTime::UNIX_EPOCH.naive_utc(),
+            updated_at: chrono::DateTime::UNIX_EPOCH.naive_utc(),
+            book_dir_path: "Author/Title (1)".to_string(),
+        }
+    }
+
+    #[test]
+    fn no_cover_flag_yields_no_cover_url() {
+        assert!(book_cover_image("/library", &test_book(false)).is_none());
+    }
+
+    /// `has_cover` is trusted without statting cover.jpg (the per-book
+    /// `PathBuf::exists` dominated list-all at 5k books). A stale flag
+    /// yields a dangling URL, which the frontend's onerror fallback absorbs.
+    #[test]
+    fn has_cover_flag_trusted_without_filesystem_check() {
+        let cover = book_cover_image("/definitely/not/a/real/library", &test_book(true))
+            .expect("has_cover implies a cover URL");
+        assert!(matches!(cover.kind, LocalOrRemote::Local));
+        let path = cover.local_path.expect("local cover keeps its path");
+        assert!(path.ends_with("cover.jpg"));
+        assert!(!path.exists());
+        assert!(cover.url.contains("cover.jpg"));
+    }
+}

src-tauri/src/libs/calibre/command.rs

@@ -200,6 +200,9 @@ pub fn clb_cmd_create_authors(
     new_authors: Vec<NewAuthor>,
 ) -> Result<Vec<LibraryAuthor>, String> {
     state.with_library(|lib| {
+        // Freshly created authors have no linked books yet, so an empty
+        // counts map is exact (from_author defaults missing entries to 0).
+        let no_book_counts = std::collections::HashMap::new();
         let mut created = Vec::new();
         for author in &new_authors {
             let author_add = libcalibre::AuthorAdd {
@@ -209,7 +212,7 @@ pub fn clb_cmd_create_authors(
             };
             let author_id = lib.add_author(author_add).map_err(|e| e.to_string())?;
             let library_author = lib.get_author(author_id).map_err(|e| e.to_string())?;
-            created.push(LibraryAuthor::from(&library_author));
+            created.push(LibraryAuthor::from_author(&library_author, &no_book_counts));
         }
         Ok(created)
     })?

src-tauri/src/libs/calibre/query.rs

@@ -151,8 +151,13 @@ pub fn clb_query_list_all_authors(
 ) -> Result<Vec<LibraryAuthor>, String> {
     state
         .with_library(|lib| {
-            lib.authors()
-                .map(|author_list| author_list.iter().map(LibraryAuthor::from).collect())
+            let book_counts = lib.author_book_counts()?;
+            lib.authors().map(|author_list| {
+                author_list
+                    .iter()
+                    .map(|author| LibraryAuthor::from_author(author, &book_counts))
+                    .collect()
+            })
         })
         .and_then(|result| result.map_err(|e| format!("Failed to list authors: {}", e)))
 }

src/bindings.ts

@@ -304,7 +304,14 @@ path: string; publication_date: string | null;
 file_contains_cover: boolean }
 export type ImportableBookType = "Epub" | "Pdf" | "Mobi" | "Text"
 export type ImportableFile = { path: string }
-export type LibraryAuthor = { id: string; name: string; sortable_name: string }
+export type LibraryAuthor = { id: string; name: string; sortable_name: string;
+/**
+ * Number of books in the library linked to this author, from
+ * `Library::author_book_counts` (one GROUP BY pass over
+ * `books_authors_link`). The Authors page renders this directly
+ * instead of deriving counts from the whole book list.
+ */
+book_count: number }
 export type LibraryBook = { id: string; uuid: string | null; title: string; author_list: LibraryAuthor[]; tag_list: string[]; sortable_title: string | null; file_list: BookFile[]; cover_image: LocalOrRemoteUrl | null; identifier_list: Identifier[]; description: string | null; is_read: boolean; series: string | null; series_index: number | null }
 export type LibraryBookPage = { items: LibraryBook[];
 /**