chore: bump version to 1.12.0

Add a new GET /authors endpoint that aggregates unique authors from books
with book/series counts, pagination and search. Add author filter to
GET /books. Backoffice gets a list page with search/sort and a detail
page showing the author's series and books.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Cargo.lock

@@ -64,7 +64,7 @@ checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
 [[package]]
 name = "api"
-version = "1.11.1"
+version = "1.12.0"
 dependencies = [
  "anyhow",
  "argon2",
@@ -1232,7 +1232,7 @@ dependencies = [
 
 [[package]]
 name = "indexer"
-version = "1.11.1"
+version = "1.12.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -1771,7 +1771,7 @@ dependencies = [
 
 [[package]]
 name = "parsers"
-version = "1.11.1"
+version = "1.12.0"
 dependencies = [
  "anyhow",
  "flate2",
@@ -2906,7 +2906,7 @@ dependencies = [
 
 [[package]]
 name = "stripstream-core"
-version = "1.11.1"
+version = "1.12.0"
 dependencies = [
  "anyhow",
  "serde",

Cargo.toml

@@ -9,7 +9,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "1.11.1"
+version = "1.12.0"
 license = "MIT"
 
 [workspace.dependencies]

apps/api/src/authors.rs

@@ -0,0 +1,156 @@
+use axum::{extract::{Query, State}, Json};
+use serde::{Deserialize, Serialize};
+use sqlx::Row;
+use utoipa::ToSchema;
+
+use crate::{error::ApiError, state::AppState};
+
+#[derive(Deserialize, ToSchema)]
+pub struct ListAuthorsQuery {
+    #[schema(value_type = Option<String>, example = "batman")]
+    pub q: Option<String>,
+    #[schema(value_type = Option<i64>, example = 1)]
+    pub page: Option<i64>,
+    #[schema(value_type = Option<i64>, example = 20)]
+    pub limit: Option<i64>,
+    /// Sort order: "name" (default), "books" (most books first)
+    #[schema(value_type = Option<String>, example = "books")]
+    pub sort: Option<String>,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct AuthorItem {
+    pub name: String,
+    pub book_count: i64,
+    pub series_count: i64,
+}
+
+#[derive(Serialize, ToSchema)]
+pub struct AuthorsPageResponse {
+    pub items: Vec<AuthorItem>,
+    pub total: i64,
+    pub page: i64,
+    pub limit: i64,
+}
+
+/// List all unique authors with book/series counts
+#[utoipa::path(
+    get,
+    path = "/authors",
+    tag = "authors",
+    params(
+        ("q" = Option<String>, Query, description = "Search by author name"),
+        ("page" = Option<i64>, Query, description = "Page number (1-based)"),
+        ("limit" = Option<i64>, Query, description = "Items per page (max 100)"),
+        ("sort" = Option<String>, Query, description = "Sort: name (default) or books"),
+    ),
+    responses(
+        (status = 200, body = AuthorsPageResponse),
+        (status = 401, description = "Unauthorized"),
+    ),
+    security(("Bearer" = []))
+)]
+pub async fn list_authors(
+    State(state): State<AppState>,
+    Query(query): Query<ListAuthorsQuery>,
+) -> Result<Json<AuthorsPageResponse>, ApiError> {
+    let page = query.page.unwrap_or(1).max(1);
+    let limit = query.limit.unwrap_or(20).clamp(1, 100);
+    let offset = (page - 1) * limit;
+    let sort = query.sort.as_deref().unwrap_or("name");
+
+    let order_clause = match sort {
+        "books" => "book_count DESC, name ASC",
+        _ => "name ASC",
+    };
+
+    let q_pattern = query.q.as_deref()
+        .filter(|s| !s.trim().is_empty())
+        .map(|s| format!("%{s}%"));
+
+    // Aggregate unique authors from books.authors + books.author
+    let sql = format!(
+        r#"
+        WITH all_authors AS (
+            SELECT DISTINCT UNNEST(
+                COALESCE(
+                    NULLIF(authors, '{{}}'),
+                    CASE WHEN author IS NOT NULL AND author != '' THEN ARRAY[author] ELSE ARRAY[]::text[] END
+                )
+            ) AS name
+            FROM books
+        ),
+        filtered AS (
+            SELECT name FROM all_authors
+            WHERE ($1::text IS NULL OR name ILIKE $1)
+        ),
+        counted AS (
+            SELECT
+                f.name,
+                COUNT(DISTINCT b.id) AS book_count,
+                COUNT(DISTINCT NULLIF(b.series, '')) AS series_count
+            FROM filtered f
+            JOIN books b ON (
+                f.name = ANY(
+                    COALESCE(
+                        NULLIF(b.authors, '{{}}'),
+                        CASE WHEN b.author IS NOT NULL AND b.author != '' THEN ARRAY[b.author] ELSE ARRAY[]::text[] END
+                    )
+                )
+            )
+            GROUP BY f.name
+        )
+        SELECT name, book_count, series_count
+        FROM counted
+        ORDER BY {order_clause}
+        LIMIT $2 OFFSET $3
+        "#
+    );
+
+    let count_sql = r#"
+        WITH all_authors AS (
+            SELECT DISTINCT UNNEST(
+                COALESCE(
+                    NULLIF(authors, '{}'),
+                    CASE WHEN author IS NOT NULL AND author != '' THEN ARRAY[author] ELSE ARRAY[]::text[] END
+                )
+            ) AS name
+            FROM books
+        )
+        SELECT COUNT(*) AS total
+        FROM all_authors
+        WHERE ($1::text IS NULL OR name ILIKE $1)
+    "#;
+
+    let (rows, count_row) = tokio::join!(
+        sqlx::query(&sql)
+            .bind(q_pattern.as_deref())
+            .bind(limit)
+            .bind(offset)
+            .fetch_all(&state.pool),
+        sqlx::query(count_sql)
+            .bind(q_pattern.as_deref())
+            .fetch_one(&state.pool)
+    );
+
+    let rows = rows.map_err(|e| ApiError::internal(format!("authors query failed: {e}")))?;
+    let total: i64 = count_row
+        .map_err(|e| ApiError::internal(format!("authors count failed: {e}")))?
+        .get("total");
+
+    let items: Vec<AuthorItem> = rows
+        .iter()
+        .map(|r| AuthorItem {
+            name: r.get("name"),
+            book_count: r.get("book_count"),
+            series_count: r.get("series_count"),
+        })
+        .collect();
+
+    Ok(Json(AuthorsPageResponse {
+        items,
+        total,
+        page,
+        limit,
+    }))
+}

apps/api/src/books.rs

@@ -19,6 +19,9 @@ pub struct ListBooksQuery {
     pub series: Option<String>,
     #[schema(value_type = Option<String>, example = "unread,reading")]
     pub reading_status: Option<String>,
+    /// Filter by exact author name (matches in authors array or scalar author field)
+    #[schema(value_type = Option<String>)]
+    pub author: Option<String>,
     #[schema(value_type = Option<i64>, example = 1)]
     pub page: Option<i64>,
     #[schema(value_type = Option<i64>, example = 50)]
@@ -135,6 +138,9 @@ pub async fn list_books(
     let rs_cond = if reading_statuses.is_some() {
         p += 1; format!("AND COALESCE(brp.status, 'unread') = ANY(${p})")
     } else { String::new() };
+    let author_cond = if query.author.is_some() {
+        p += 1; format!("AND (${p} = ANY(COALESCE(NULLIF(b.authors, '{{}}'), CASE WHEN b.author IS NOT NULL AND b.author != '' THEN ARRAY[b.author] ELSE ARRAY[]::text[] END)))")
+    } else { String::new() };
 
     let count_sql = format!(
         r#"SELECT COUNT(*) FROM books b
@@ -143,7 +149,8 @@ pub async fn list_books(
              AND ($2::text IS NULL OR b.kind = $2)
              AND ($3::text IS NULL OR b.format = $3)
              {series_cond}
-             {rs_cond}"#
+             {rs_cond}
+             {author_cond}"#
     );
 
     let order_clause = if query.sort.as_deref() == Some("latest") {
@@ -168,6 +175,7 @@ pub async fn list_books(
           AND ($3::text IS NULL OR b.format = $3)
           {series_cond}
           {rs_cond}
+          {author_cond}
         ORDER BY {order_clause}
         LIMIT ${limit_p} OFFSET ${offset_p}
         "#
@@ -192,6 +200,10 @@ pub async fn list_books(
         count_builder = count_builder.bind(statuses.clone());
         data_builder = data_builder.bind(statuses.clone());
     }
+    if let Some(ref author) = query.author {
+        count_builder = count_builder.bind(author.clone());
+        data_builder = data_builder.bind(author.clone());
+    }
 
     data_builder = data_builder.bind(limit).bind(offset);
 

apps/api/src/libraries.rs

@@ -23,6 +23,9 @@ pub struct LibraryResponse {
     pub watcher_enabled: bool,
     pub metadata_provider: Option<String>,
     pub fallback_metadata_provider: Option<String>,
+    pub metadata_refresh_mode: String,
+    #[schema(value_type = Option<String>)]
+    pub next_metadata_refresh_at: Option<chrono::DateTime<chrono::Utc>>,
 }
 
 #[derive(Deserialize, ToSchema)]
@@ -47,7 +50,7 @@ pub struct CreateLibraryRequest {
 )]
 pub async fn list_libraries(State(state): State<AppState>) -> Result<Json<Vec<LibraryResponse>>, ApiError> {
     let rows = sqlx::query(
-        "SELECT l.id, l.name, l.root_path, l.enabled, l.monitor_enabled, l.scan_mode, l.next_scan_at, l.watcher_enabled, l.metadata_provider, l.fallback_metadata_provider,
+        "SELECT l.id, l.name, l.root_path, l.enabled, l.monitor_enabled, l.scan_mode, l.next_scan_at, l.watcher_enabled, l.metadata_provider, l.fallback_metadata_provider, l.metadata_refresh_mode, l.next_metadata_refresh_at,
                 (SELECT COUNT(*) FROM books b WHERE b.library_id = l.id) as book_count
          FROM libraries l ORDER BY l.created_at DESC"
     )
@@ -68,6 +71,8 @@ pub async fn list_libraries(State(state): State<AppState>) -> Result<Json<Vec<Li
             watcher_enabled: row.get("watcher_enabled"),
             metadata_provider: row.get("metadata_provider"),
             fallback_metadata_provider: row.get("fallback_metadata_provider"),
+            metadata_refresh_mode: row.get("metadata_refresh_mode"),
+            next_metadata_refresh_at: row.get("next_metadata_refresh_at"),
         })
         .collect();
 
@@ -121,6 +126,8 @@ pub async fn create_library(
         watcher_enabled: false,
         metadata_provider: None,
         fallback_metadata_provider: None,
+        metadata_refresh_mode: "manual".to_string(),
+        next_metadata_refresh_at: None,
     }))
 }
 
@@ -241,6 +248,8 @@ pub struct UpdateMonitoringRequest {
     #[schema(value_type = String, example = "hourly")]
     pub scan_mode: String, // 'manual', 'hourly', 'daily', 'weekly'
     pub watcher_enabled: Option<bool>,
+    #[schema(value_type = Option<String>, example = "daily")]
+    pub metadata_refresh_mode: Option<String>, // 'manual', 'hourly', 'daily', 'weekly'
 }
 
 /// Update monitoring settings for a library
@@ -271,6 +280,12 @@ pub async fn update_monitoring(
         return Err(ApiError::bad_request("scan_mode must be one of: manual, hourly, daily, weekly"));
     }
 
+    // Validate metadata_refresh_mode
+    let metadata_refresh_mode = input.metadata_refresh_mode.as_deref().unwrap_or("manual");
+    if !valid_modes.contains(&metadata_refresh_mode) {
+        return Err(ApiError::bad_request("metadata_refresh_mode must be one of: manual, hourly, daily, weekly"));
+    }
+
     // Calculate next_scan_at if monitoring is enabled
     let next_scan_at = if input.monitor_enabled {
         let interval_minutes = match input.scan_mode.as_str() {
@@ -284,16 +299,31 @@ pub async fn update_monitoring(
         None
     };
 
+    // Calculate next_metadata_refresh_at
+    let next_metadata_refresh_at = if metadata_refresh_mode != "manual" {
+        let interval_minutes = match metadata_refresh_mode {
+            "hourly" => 60,
+            "daily" => 1440,
+            "weekly" => 10080,
+            _ => 1440,
+        };
+        Some(chrono::Utc::now() + chrono::Duration::minutes(interval_minutes))
+    } else {
+        None
+    };
+
     let watcher_enabled = input.watcher_enabled.unwrap_or(false);
 
     let result = sqlx::query(
-        "UPDATE libraries SET monitor_enabled = $2, scan_mode = $3, next_scan_at = $4, watcher_enabled = $5 WHERE id = $1 RETURNING id, name, root_path, enabled, monitor_enabled, scan_mode, next_scan_at, watcher_enabled, metadata_provider, fallback_metadata_provider"
+        "UPDATE libraries SET monitor_enabled = $2, scan_mode = $3, next_scan_at = $4, watcher_enabled = $5, metadata_refresh_mode = $6, next_metadata_refresh_at = $7 WHERE id = $1 RETURNING id, name, root_path, enabled, monitor_enabled, scan_mode, next_scan_at, watcher_enabled, metadata_provider, fallback_metadata_provider, metadata_refresh_mode, next_metadata_refresh_at"
     )
     .bind(library_id)
     .bind(input.monitor_enabled)
     .bind(input.scan_mode)
     .bind(next_scan_at)
     .bind(watcher_enabled)
+    .bind(metadata_refresh_mode)
+    .bind(next_metadata_refresh_at)
     .fetch_optional(&state.pool)
     .await?;
 
@@ -318,6 +348,8 @@ pub async fn update_monitoring(
         watcher_enabled: row.get("watcher_enabled"),
         metadata_provider: row.get("metadata_provider"),
         fallback_metadata_provider: row.get("fallback_metadata_provider"),
+        metadata_refresh_mode: row.get("metadata_refresh_mode"),
+        next_metadata_refresh_at: row.get("next_metadata_refresh_at"),
     }))
 }
 
@@ -353,7 +385,7 @@ pub async fn update_metadata_provider(
     let fallback = input.fallback_metadata_provider.as_deref().filter(|s| !s.is_empty());
 
     let result = sqlx::query(
-        "UPDATE libraries SET metadata_provider = $2, fallback_metadata_provider = $3 WHERE id = $1 RETURNING id, name, root_path, enabled, monitor_enabled, scan_mode, next_scan_at, watcher_enabled, metadata_provider, fallback_metadata_provider"
+        "UPDATE libraries SET metadata_provider = $2, fallback_metadata_provider = $3 WHERE id = $1 RETURNING id, name, root_path, enabled, monitor_enabled, scan_mode, next_scan_at, watcher_enabled, metadata_provider, fallback_metadata_provider, metadata_refresh_mode, next_metadata_refresh_at"
     )
     .bind(library_id)
     .bind(provider)
@@ -382,5 +414,7 @@ pub async fn update_metadata_provider(
         watcher_enabled: row.get("watcher_enabled"),
         metadata_provider: row.get("metadata_provider"),
         fallback_metadata_provider: row.get("fallback_metadata_provider"),
+        metadata_refresh_mode: row.get("metadata_refresh_mode"),
+        next_metadata_refresh_at: row.get("next_metadata_refresh_at"),
     }))
 }

apps/api/src/main.rs

@@ -1,4 +1,5 @@
 mod auth;
+mod authors;
 mod books;
 mod error;
 mod handlers;
@@ -145,6 +146,7 @@ async fn main() -> anyhow::Result<()> {
         .route("/series/statuses", get(books::series_statuses))
         .route("/series/provider-statuses", get(books::provider_statuses))
         .route("/series/mark-read", axum::routing::post(reading_progress::mark_series_read))
+        .route("/authors", get(authors::list_authors))
         .route("/stats", get(stats::get_stats))
         .route("/search", get(search::search_books))
         .route_layer(middleware::from_fn_with_state(state.clone(), api_middleware::read_rate_limit))

apps/api/src/openapi.rs

@@ -39,6 +39,7 @@ use utoipa::OpenApi;
         crate::tokens::create_token,
         crate::tokens::revoke_token,
         crate::tokens::delete_token,
+        crate::authors::list_authors,
         crate::stats::get_stats,
         crate::settings::get_settings,
         crate::settings::get_setting,
@@ -104,6 +105,9 @@ use utoipa::OpenApi;
             crate::settings::ThumbnailStats,
             crate::settings::StatusMappingDto,
             crate::settings::UpsertStatusMappingRequest,
+            crate::authors::ListAuthorsQuery,
+            crate::authors::AuthorItem,
+            crate::authors::AuthorsPageResponse,
             crate::stats::StatsResponse,
             crate::stats::StatsOverview,
             crate::stats::ReadingStatusStats,
@@ -141,6 +145,7 @@ use utoipa::OpenApi;
         ("Bearer" = [])
     ),
     tags(
+        (name = "authors", description = "Author browsing and listing"),
         (name = "books", description = "Read-only endpoints for browsing and searching books"),
         (name = "reading-progress", description = "Reading progress tracking per book"),
         (name = "libraries", description = "Library management endpoints (Admin only)"),

apps/backoffice/app/authors/[name]/page.tsx

@@ -0,0 +1,142 @@
+import { fetchBooks, fetchAllSeries, BooksPageDto, SeriesPageDto, getBookCoverUrl } from "../../../lib/api";
+import { getServerTranslations } from "../../../lib/i18n/server";
+import { BooksGrid } from "../../components/BookCard";
+import { OffsetPagination } from "../../components/ui";
+import Image from "next/image";
+import Link from "next/link";
+
+export const dynamic = "force-dynamic";
+
+export default async function AuthorDetailPage({
+  params,
+  searchParams,
+}: {
+  params: Promise<{ name: string }>;
+  searchParams: Promise<{ [key: string]: string | string[] | undefined }>;
+}) {
+  const { t } = await getServerTranslations();
+  const { name: encodedName } = await params;
+  const authorName = decodeURIComponent(encodedName);
+  const searchParamsAwaited = await searchParams;
+  const page = typeof searchParamsAwaited.page === "string" ? parseInt(searchParamsAwaited.page) : 1;
+  const limit = typeof searchParamsAwaited.limit === "string" ? parseInt(searchParamsAwaited.limit) : 20;
+
+  // Fetch books by this author (server-side filtering via API) and series
+  const [booksPage, seriesPage] = await Promise.all([
+    fetchBooks(undefined, undefined, page, limit, undefined, undefined, authorName).catch(
+      () => ({ items: [], total: 0, page: 1, limit }) as BooksPageDto
+    ),
+    fetchAllSeries(undefined, undefined, undefined, 1, 200).catch(
+      () => ({ items: [], total: 0, page: 1, limit: 200 }) as SeriesPageDto
+    ),
+  ]);
+
+  const totalPages = Math.ceil(booksPage.total / limit);
+
+  // Extract unique series names from this author's books
+  const authorSeriesNames = new Set(
+    booksPage.items
+      .map((b) => b.series)
+      .filter((s): s is string => s != null && s !== "")
+  );
+
+  const authorSeries = seriesPage.items.filter((s) => authorSeriesNames.has(s.name));
+
+  return (
+    <>
+      {/* Breadcrumb */}
+      <nav className="flex items-center gap-2 text-sm text-muted-foreground mb-6">
+        <Link href="/authors" className="hover:text-foreground transition-colors">
+          {t("authors.title")}
+        </Link>
+        <span>/</span>
+        <span className="text-foreground font-medium">{authorName}</span>
+      </nav>
+
+      {/* Author Header */}
+      <div className="flex items-center gap-4 mb-8">
+        <div className="w-16 h-16 rounded-full bg-accent/50 flex items-center justify-center flex-shrink-0">
+          <span className="text-2xl font-bold text-accent-foreground">
+            {authorName.charAt(0).toUpperCase()}
+          </span>
+        </div>
+        <div>
+          <h1 className="text-3xl font-bold text-foreground">{authorName}</h1>
+          <div className="flex items-center gap-4 mt-1">
+            <span className="text-sm text-muted-foreground">
+              {t("authors.bookCount", { count: String(booksPage.total), plural: booksPage.total !== 1 ? "s" : "" })}
+            </span>
+            {authorSeries.length > 0 && (
+              <span className="text-sm text-muted-foreground">
+                {t("authors.seriesCount", { count: String(authorSeries.length), plural: authorSeries.length !== 1 ? "s" : "" })}
+              </span>
+            )}
+          </div>
+        </div>
+      </div>
+
+      {/* Series Section */}
+      {authorSeries.length > 0 && (
+        <section className="mb-8">
+          <h2 className="text-xl font-semibold text-foreground mb-4">
+            {t("authors.seriesBy", { name: authorName })}
+          </h2>
+          <div className="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 xl:grid-cols-6 gap-4">
+            {authorSeries.map((s) => (
+              <Link
+                key={`${s.library_id}-${s.name}`}
+                href={`/libraries/${s.library_id}/series/${encodeURIComponent(s.name)}`}
+                className="group"
+              >
+                <div className="bg-card rounded-xl shadow-sm border border-border/60 overflow-hidden hover:shadow-md hover:-translate-y-1 transition-all duration-200">
+                  <div className="aspect-[2/3] relative bg-muted/50">
+                    <Image
+                      src={getBookCoverUrl(s.first_book_id)}
+                      alt={s.name}
+                      fill
+                      className="object-cover"
+                      unoptimized
+                    />
+                  </div>
+                  <div className="p-3">
+                    <h3 className="font-medium text-foreground truncate text-sm" title={s.name}>
+                      {s.name}
+                    </h3>
+                    <p className="text-xs text-muted-foreground mt-1">
+                      {t("authors.bookCount", { count: String(s.book_count), plural: s.book_count !== 1 ? "s" : "" })}
+                    </p>
+                  </div>
+                </div>
+              </Link>
+            ))}
+          </div>
+        </section>
+      )}
+
+      {/* Books Section */}
+      {booksPage.items.length > 0 && (
+        <section>
+          <h2 className="text-xl font-semibold text-foreground mb-4">
+            {t("authors.booksBy", { name: authorName })}
+          </h2>
+          <BooksGrid books={booksPage.items} />
+          <OffsetPagination
+            currentPage={page}
+            totalPages={totalPages}
+            pageSize={limit}
+            totalItems={booksPage.total}
+          />
+        </section>
+      )}
+
+      {/* Empty State */}
+      {booksPage.items.length === 0 && authorSeries.length === 0 && (
+        <div className="flex flex-col items-center justify-center py-16 text-center">
+          <p className="text-muted-foreground text-lg">
+            {t("authors.noResults")}
+          </p>
+        </div>
+      )}
+    </>
+  );
+}

apps/backoffice/app/authors/page.tsx

@@ -0,0 +1,122 @@
+import { fetchAuthors, AuthorsPageDto } from "../../lib/api";
+import { getServerTranslations } from "../../lib/i18n/server";
+import { LiveSearchForm } from "../components/LiveSearchForm";
+import { Card, CardContent, OffsetPagination } from "../components/ui";
+import Link from "next/link";
+
+export const dynamic = "force-dynamic";
+
+export default async function AuthorsPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ [key: string]: string | string[] | undefined }>;
+}) {
+  const { t } = await getServerTranslations();
+  const searchParamsAwaited = await searchParams;
+  const searchQuery = typeof searchParamsAwaited.q === "string" ? searchParamsAwaited.q : "";
+  const sort = typeof searchParamsAwaited.sort === "string" ? searchParamsAwaited.sort : undefined;
+  const page = typeof searchParamsAwaited.page === "string" ? parseInt(searchParamsAwaited.page) : 1;
+  const limit = typeof searchParamsAwaited.limit === "string" ? parseInt(searchParamsAwaited.limit) : 20;
+
+  const authorsPage = await fetchAuthors(
+    searchQuery || undefined,
+    page,
+    limit,
+    sort,
+  ).catch(() => ({ items: [], total: 0, page: 1, limit }) as AuthorsPageDto);
+
+  const totalPages = Math.ceil(authorsPage.total / limit);
+  const hasFilters = searchQuery || sort;
+
+  const sortOptions = [
+    { value: "", label: t("authors.sortName") },
+    { value: "books", label: t("authors.sortBooks") },
+  ];
+
+  return (
+    <>
+      <div className="mb-6">
+        <h1 className="text-3xl font-bold text-foreground flex items-center gap-3">
+          <svg className="w-8 h-8 text-violet-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0zm6 3a2 2 0 11-4 0 2 2 0 014 0zM7 10a2 2 0 11-4 0 2 2 0 014 0z" />
+          </svg>
+          {t("authors.title")}
+        </h1>
+      </div>
+
+      <Card className="mb-6">
+        <CardContent className="pt-6">
+          <LiveSearchForm
+            basePath="/authors"
+            fields={[
+              { name: "q", type: "text", label: t("common.search"), placeholder: t("authors.searchPlaceholder") },
+              { name: "sort", type: "select", label: t("books.sort"), options: sortOptions },
+            ]}
+          />
+        </CardContent>
+      </Card>
+
+      {/* Results count */}
+      <p className="text-sm text-muted-foreground mb-4">
+        {authorsPage.total} {t("authors.title").toLowerCase()}
+        {searchQuery && <> {t("authors.matchingQuery")} &quot;{searchQuery}&quot;</>}
+      </p>
+
+      {/* Authors List */}
+      {authorsPage.items.length > 0 ? (
+        <>
+          <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-4">
+            {authorsPage.items.map((author) => (
+              <Link
+                key={author.name}
+                href={`/authors/${encodeURIComponent(author.name)}`}
+                className="group"
+              >
+                <div className="bg-card rounded-xl shadow-sm border border-border/60 overflow-hidden hover:shadow-md hover:-translate-y-1 transition-all duration-200 p-4">
+                  <div className="flex items-center gap-3">
+                    <div className="w-10 h-10 rounded-full bg-accent/50 flex items-center justify-center flex-shrink-0">
+                      <span className="text-lg font-semibold text-violet-500">
+                        {author.name.charAt(0).toUpperCase()}
+                      </span>
+                    </div>
+                    <div className="min-w-0">
+                      <h3 className="font-medium text-foreground truncate text-sm group-hover:text-violet-500 transition-colors" title={author.name}>
+                        {author.name}
+                      </h3>
+                      <div className="flex items-center gap-3 mt-0.5">
+                        <span className="text-xs text-muted-foreground">
+                          {t("authors.bookCount", { count: String(author.book_count), plural: author.book_count !== 1 ? "s" : "" })}
+                        </span>
+                        <span className="text-xs text-muted-foreground">
+                          {t("authors.seriesCount", { count: String(author.series_count), plural: author.series_count !== 1 ? "s" : "" })}
+                        </span>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              </Link>
+            ))}
+          </div>
+
+          <OffsetPagination
+            currentPage={page}
+            totalPages={totalPages}
+            pageSize={limit}
+            totalItems={authorsPage.total}
+          />
+        </>
+      ) : (
+        <div className="flex flex-col items-center justify-center py-16 text-center">
+          <div className="w-16 h-16 mb-4 text-muted-foreground/30">
+            <svg fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0zm6 3a2 2 0 11-4 0 2 2 0 014 0zM7 10a2 2 0 11-4 0 2 2 0 014 0z" />
+            </svg>
+          </div>
+          <p className="text-muted-foreground text-lg">
+            {hasFilters ? t("authors.noResults") : t("authors.noAuthors")}
+          </p>
+        </div>
+      )}
+    </>
+  );
+}

apps/backoffice/app/components/LibraryActions.tsx

@@ -12,6 +12,7 @@ interface LibraryActionsProps {
   watcherEnabled: boolean;
   metadataProvider: string | null;
   fallbackMetadataProvider: string | null;
+  metadataRefreshMode: string;
   onUpdate?: () => void;
 }
 
@@ -22,6 +23,7 @@ export function LibraryActions({
   watcherEnabled,
   metadataProvider,
   fallbackMetadataProvider,
+  metadataRefreshMode,
   onUpdate
 }: LibraryActionsProps) {
   const { t } = useTranslation();
@@ -48,6 +50,7 @@ export function LibraryActions({
       const scanMode = formData.get("scan_mode") as string;
       const newMetadataProvider = (formData.get("metadata_provider") as string) || null;
       const newFallbackProvider = (formData.get("fallback_metadata_provider") as string) || null;
+      const newMetadataRefreshMode = formData.get("metadata_refresh_mode") as string;
 
       try {
         const [response] = await Promise.all([
@@ -58,6 +61,7 @@ export function LibraryActions({
               monitor_enabled: monitorEnabled,
               scan_mode: scanMode,
               watcher_enabled: watcherEnabled,
+              metadata_refresh_mode: newMetadataRefreshMode,
             }),
           }),
           fetch(`/api/libraries/${libraryId}/metadata-provider`, {
@@ -181,6 +185,20 @@ export function LibraryActions({
                 </select>
               </div>
 
+              <div className="flex items-center justify-between">
+                <label className="text-sm font-medium text-foreground">{t("libraryActions.metadataRefreshSchedule")}</label>
+                <select
+                  name="metadata_refresh_mode"
+                  defaultValue={metadataRefreshMode}
+                  className="text-sm border border-border rounded-lg px-2 py-1 bg-background"
+                >
+                  <option value="manual">{t("monitoring.manual")}</option>
+                  <option value="hourly">{t("monitoring.hourly")}</option>
+                  <option value="daily">{t("monitoring.daily")}</option>
+                  <option value="weekly">{t("monitoring.weekly")}</option>
+                </select>
+              </div>
+
               {saveError && (
                 <p className="text-xs text-destructive bg-destructive/10 px-2 py-1.5 rounded-lg break-all">
                   {saveError}

apps/backoffice/app/components/MobileNav.tsx

@@ -7,9 +7,9 @@ import { NavIcon } from "./ui";
 import { useTranslation } from "../../lib/i18n/context";
 
 type NavItem = {
-  href: "/" | "/books" | "/series" | "/libraries" | "/jobs" | "/tokens" | "/settings";
+  href: "/" | "/books" | "/series" | "/authors" | "/libraries" | "/jobs" | "/tokens" | "/settings";
   label: string;
-  icon: "dashboard" | "books" | "series" | "libraries" | "jobs" | "tokens" | "settings";
+  icon: "dashboard" | "books" | "series" | "authors" | "libraries" | "jobs" | "tokens" | "settings";
 };
 
 const HamburgerIcon = () => (

apps/backoffice/app/components/ui/Icon.tsx

@@ -33,7 +33,8 @@ type IconName =
   | "spinner"
   | "warning"
   | "tag"
-  | "document";
+  | "document"
+  | "authors";
 
 type IconSize = "sm" | "md" | "lg" | "xl";
 
@@ -86,6 +87,7 @@ const icons: Record<IconName, string> = {
   warning: "M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z",
   tag: "M7 7h.01M7 3h5a1.99 1.99 0 011.414.586l7 7a2 2 0 010 2.828l-7 7a2 2 0 01-2.828 0l-7-7A1.994 1.994 0 013 12V7a4 4 0 014-4z",
   document: "M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z",
+  authors: "M17 20h5v-2a3 3 0 00-5.356-1.857M17 20H7m10 0v-2c0-.656-.126-1.283-.356-1.857M7 20H2v-2a3 3 0 015.356-1.857M7 20v-2c0-.656.126-1.283.356-1.857m0 0a5.002 5.002 0 019.288 0M15 7a3 3 0 11-6 0 3 3 0 016 0zm6 3a2 2 0 11-4 0 2 2 0 014 0zM7 10a2 2 0 11-4 0 2 2 0 014 0z",
 };
 
 const colorClasses: Partial<Record<IconName, string>> = {
@@ -99,6 +101,7 @@ const colorClasses: Partial<Record<IconName, string>> = {
   image: "text-primary",
   cache: "text-warning",
   performance: "text-success",
+  authors: "text-violet-500",
 };
 
 export function Icon({ name, size = "md", className = "" }: IconProps) {

apps/backoffice/app/layout.tsx

@@ -18,15 +18,16 @@ export const metadata: Metadata = {
 };
 
 type NavItem = {
-  href: "/" | "/books" | "/series" | "/libraries" | "/jobs" | "/tokens" | "/settings";
+  href: "/" | "/books" | "/series" | "/authors" | "/libraries" | "/jobs" | "/tokens" | "/settings";
   labelKey: TranslationKey;
-  icon: "dashboard" | "books" | "series" | "libraries" | "jobs" | "tokens" | "settings";
+  icon: "dashboard" | "books" | "series" | "authors" | "libraries" | "jobs" | "tokens" | "settings";
 };
 
 const navItems: NavItem[] = [
   { href: "/", labelKey: "nav.dashboard", icon: "dashboard" },
   { href: "/books", labelKey: "nav.books", icon: "books" },
   { href: "/series", labelKey: "nav.series", icon: "series" },
+  { href: "/authors", labelKey: "nav.authors", icon: "authors" },
   { href: "/libraries", labelKey: "nav.libraries", icon: "libraries" },
   { href: "/jobs", labelKey: "nav.jobs", icon: "jobs" },
   { href: "/tokens", labelKey: "nav.tokens", icon: "tokens" },

apps/backoffice/app/libraries/page.tsx

@@ -131,6 +131,7 @@ export default async function LibrariesPage() {
                     watcherEnabled={lib.watcher_enabled}
                     metadataProvider={lib.metadata_provider}
                     fallbackMetadataProvider={lib.fallback_metadata_provider}
+                    metadataRefreshMode={lib.metadata_refresh_mode}
                   />
                 </div>
               </CardHeader>
@@ -169,6 +170,11 @@ export default async function LibrariesPage() {
                       {t("libraries.nextScan", { time: formatNextScan(lib.next_scan_at, t("libraries.imminent")) })}
                     </span>
                   )}
+                  {lib.metadata_refresh_mode !== "manual" && lib.next_metadata_refresh_at && (
+                    <span className="text-xs text-muted-foreground ml-auto" title={t("libraries.nextMetadataRefresh", { time: formatNextScan(lib.next_metadata_refresh_at, t("libraries.imminent")) })}>
+                      {t("libraries.nextMetadataRefreshShort", { time: formatNextScan(lib.next_metadata_refresh_at, t("libraries.imminent")) })}
+                    </span>
+                  )}
                 </div>
 
                 {/* Actions */}

apps/backoffice/lib/api.ts

@@ -284,12 +284,14 @@ export async function fetchBooks(
   limit: number = 50,
   readingStatus?: string,
   sort?: string,
+  author?: string,
 ): Promise<BooksPageDto> {
   const params = new URLSearchParams();
   if (libraryId) params.set("library_id", libraryId);
   if (series) params.set("series", series);
   if (readingStatus) params.set("reading_status", readingStatus);
   if (sort) params.set("sort", sort);
+  if (author) params.set("author", author);
   params.set("page", page.toString());
   params.set("limit", limit.toString());
 
@@ -552,6 +554,38 @@ export async function fetchStats() {
   return apiFetch<StatsResponse>("/stats");
 }
 
+// ---------------------------------------------------------------------------
+// Authors
+// ---------------------------------------------------------------------------
+
+export type AuthorDto = {
+  name: string;
+  book_count: number;
+  series_count: number;
+};
+
+export type AuthorsPageDto = {
+  items: AuthorDto[];
+  total: number;
+  page: number;
+  limit: number;
+};
+
+export async function fetchAuthors(
+  q?: string,
+  page: number = 1,
+  limit: number = 20,
+  sort?: string,
+): Promise<AuthorsPageDto> {
+  const params = new URLSearchParams();
+  if (q) params.set("q", q);
+  if (sort) params.set("sort", sort);
+  params.set("page", page.toString());
+  params.set("limit", limit.toString());
+
+  return apiFetch<AuthorsPageDto>(`/authors?${params.toString()}`);
+}
+
 export type UpdateBookRequest = {
   title: string;
   author: string | null;

apps/backoffice/lib/i18n/en.ts

@@ -113,6 +113,20 @@ const en: Record<TranslationKey, string> = {
   "series.missingCount": "{{count}} missing",
   "series.readCount": "{{read}}/{{total}} read",
 
+  // Authors page
+  "nav.authors": "Authors",
+  "authors.title": "Authors",
+  "authors.searchPlaceholder": "Search by author name...",
+  "authors.bookCount": "{{count}} book{{plural}}",
+  "authors.seriesCount": "{{count}} serie{{plural}}",
+  "authors.noResults": "No authors found matching your filters",
+  "authors.noAuthors": "No authors available",
+  "authors.matchingQuery": "matching",
+  "authors.sortName": "Name",
+  "authors.sortBooks": "Book count",
+  "authors.booksBy": "Books by {{name}}",
+  "authors.seriesBy": "Series by {{name}}",
+
   // Libraries page
   "libraries.title": "Libraries",
   "libraries.addLibrary": "Add a library",
@@ -124,6 +138,8 @@ const en: Record<TranslationKey, string> = {
   "libraries.manual": "Manual",
   "libraries.nextScan": "Next: {{time}}",
   "libraries.imminent": "Imminent",
+  "libraries.nextMetadataRefresh": "Next metadata refresh: {{time}}",
+  "libraries.nextMetadataRefreshShort": "Meta.: {{time}}",
   "libraries.index": "Index",
   "libraries.fullIndex": "Full",
   "libraries.batchMetadata": "Batch metadata",
@@ -148,6 +164,7 @@ const en: Record<TranslationKey, string> = {
   "libraryActions.fallback": "Fallback",
   "libraryActions.default": "Default",
   "libraryActions.none": "None",
+  "libraryActions.metadataRefreshSchedule": "Refresh meta.",
   "libraryActions.saving": "Saving...",
 
   // Library sub-page header

apps/backoffice/lib/i18n/fr.ts

@@ -111,6 +111,20 @@ const fr = {
   "series.missingCount": "{{count}} manquant{{plural}}",
   "series.readCount": "{{read}}/{{total}} lu{{plural}}",
 
+  // Authors page
+  "nav.authors": "Auteurs",
+  "authors.title": "Auteurs",
+  "authors.searchPlaceholder": "Rechercher par nom d'auteur...",
+  "authors.bookCount": "{{count}} livre{{plural}}",
+  "authors.seriesCount": "{{count}} série{{plural}}",
+  "authors.noResults": "Aucun auteur trouvé correspondant à vos filtres",
+  "authors.noAuthors": "Aucun auteur disponible",
+  "authors.matchingQuery": "correspondant à",
+  "authors.sortName": "Nom",
+  "authors.sortBooks": "Nombre de livres",
+  "authors.booksBy": "Livres de {{name}}",
+  "authors.seriesBy": "Séries de {{name}}",
+
   // Libraries page
   "libraries.title": "Bibliothèques",
   "libraries.addLibrary": "Ajouter une bibliothèque",
@@ -122,6 +136,8 @@ const fr = {
   "libraries.manual": "Manuel",
   "libraries.nextScan": "Prochain : {{time}}",
   "libraries.imminent": "Imminent",
+  "libraries.nextMetadataRefresh": "Prochain rafraîchissement méta. : {{time}}",
+  "libraries.nextMetadataRefreshShort": "Méta. : {{time}}",
   "libraries.index": "Indexer",
   "libraries.fullIndex": "Complet",
   "libraries.batchMetadata": "Métadonnées en lot",
@@ -146,6 +162,7 @@ const fr = {
   "libraryActions.fallback": "Secours",
   "libraryActions.default": "Par défaut",
   "libraryActions.none": "Aucun",
+  "libraryActions.metadataRefreshSchedule": "Rafraîchir méta.",
   "libraryActions.saving": "Enregistrement...",
 
   // Library sub-page header

apps/backoffice/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stripstream-backoffice",
-  "version": "1.11.1",
+  "version": "1.12.0",
   "private": true,
   "scripts": {
     "dev": "next dev -p 7082",

apps/indexer/src/scheduler.rs

@@ -26,15 +26,15 @@ pub async fn check_and_schedule_auto_scans(pool: &PgPool) -> Result<()> {
     for row in libraries {
         let library_id: Uuid = row.get("id");
         let scan_mode: String = row.get("scan_mode");
-        
+
         info!("[SCHEDULER] Auto-scanning library {} (mode: {})", library_id, scan_mode);
-        
+
         let job_id = Uuid::new_v4();
         let job_type = match scan_mode.as_str() {
             "full" => "full_rebuild",
             _ => "rebuild",
         };
-        
+
         sqlx::query(
             "INSERT INTO index_jobs (id, library_id, type, status) VALUES ($1, $2, $3, 'pending')"
         )
@@ -43,7 +43,7 @@ pub async fn check_and_schedule_auto_scans(pool: &PgPool) -> Result<()> {
         .bind(job_type)
         .execute(pool)
         .await?;
-        
+
         // Update next_scan_at
         let interval_minutes = match scan_mode.as_str() {
             "hourly" => 60,
@@ -51,7 +51,7 @@ pub async fn check_and_schedule_auto_scans(pool: &PgPool) -> Result<()> {
             "weekly" => 10080,
             _ => 1440, // default daily
         };
-        
+
         sqlx::query(
             "UPDATE libraries SET last_scan_at = NOW(), next_scan_at = NOW() + INTERVAL '1 minute' * $2 WHERE id = $1"
         )
@@ -59,9 +59,71 @@ pub async fn check_and_schedule_auto_scans(pool: &PgPool) -> Result<()> {
         .bind(interval_minutes)
         .execute(pool)
         .await?;
-        
+
         info!("[SCHEDULER] Created job {} for library {}", job_id, library_id);
     }
-    
+
+    Ok(())
+}
+
+pub async fn check_and_schedule_metadata_refreshes(pool: &PgPool) -> Result<()> {
+    let libraries = sqlx::query(
+        r#"
+        SELECT id, metadata_refresh_mode
+        FROM libraries
+        WHERE metadata_refresh_mode != 'manual'
+          AND (
+            next_metadata_refresh_at IS NULL
+            OR next_metadata_refresh_at <= NOW()
+          )
+          AND NOT EXISTS (
+            SELECT 1 FROM index_jobs
+            WHERE library_id = libraries.id
+              AND type = 'metadata_refresh'
+              AND status IN ('pending', 'running')
+          )
+          AND EXISTS (
+            SELECT 1 FROM external_metadata_links
+            WHERE library_id = libraries.id
+              AND status = 'approved'
+          )
+        "#
+    )
+    .fetch_all(pool)
+    .await?;
+
+    for row in libraries {
+        let library_id: Uuid = row.get("id");
+        let refresh_mode: String = row.get("metadata_refresh_mode");
+
+        info!("[SCHEDULER] Auto-refreshing metadata for library {} (mode: {})", library_id, refresh_mode);
+
+        let job_id = Uuid::new_v4();
+        sqlx::query(
+            "INSERT INTO index_jobs (id, library_id, type, status) VALUES ($1, $2, 'metadata_refresh', 'pending')"
+        )
+        .bind(job_id)
+        .bind(library_id)
+        .execute(pool)
+        .await?;
+
+        let interval_minutes = match refresh_mode.as_str() {
+            "hourly" => 60,
+            "daily" => 1440,
+            "weekly" => 10080,
+            _ => 1440,
+        };
+
+        sqlx::query(
+            "UPDATE libraries SET last_metadata_refresh_at = NOW(), next_metadata_refresh_at = NOW() + INTERVAL '1 minute' * $2 WHERE id = $1"
+        )
+        .bind(library_id)
+        .bind(interval_minutes)
+        .execute(pool)
+        .await?;
+
+        info!("[SCHEDULER] Created metadata_refresh job {} for library {}", job_id, library_id);
+    }
+
     Ok(())
 }

apps/indexer/src/worker.rs

@@ -27,6 +27,9 @@ pub async fn run_worker(state: AppState, interval_seconds: u64) {
             if let Err(err) = scheduler::check_and_schedule_auto_scans(&scheduler_state.pool).await {
                 error!("[SCHEDULER] Error: {}", err);
             }
+            if let Err(err) = scheduler::check_and_schedule_metadata_refreshes(&scheduler_state.pool).await {
+                error!("[SCHEDULER] Metadata refresh error: {}", err);
+            }
             tokio::time::sleep(scheduler_wait).await;
         }
     });

infra/migrations/0045_add_metadata_refresh_schedule.sql

@@ -0,0 +1,4 @@
+ALTER TABLE libraries
+  ADD COLUMN metadata_refresh_mode TEXT NOT NULL DEFAULT 'manual',
+  ADD COLUMN last_metadata_refresh_at TIMESTAMPTZ,
+  ADD COLUMN next_metadata_refresh_at TIMESTAMPTZ;