- (null);
const [showModal, setShowModal] = useState(false);
const [localRequestStatus, setLocalRequestStatus] = useState(undefined);
+ const [coverError, setCoverError] = useState(false);
// Build a display-only audiobook with the local status override
const displayAudiobook = localRequestStatus !== undefined
@@ -113,20 +116,23 @@ export function AudiobookCard({
`}
>
{/* Cover Art */}
- {audiobook.coverArtUrl ? (
+ {audiobook.coverArtUrl && !coverError ? (
setCoverError(true)}
/>
) : (
- (requestStatus ?? null);
const [isDownloading, setIsDownloading] = useState(false);
+ const [coverError, setCoverError] = useState(false);
// Sync local status when the prop changes (e.g. page data refreshes)
useEffect(() => {
@@ -287,7 +288,7 @@ export function AudiobookDetailsModal({
${squareCovers ? 'w-40 sm:w-44 lg:w-52 aspect-square' : 'w-32 sm:w-40 lg:w-48 aspect-[2/3]'}
${status.type === 'available' ? 'ring-2 ring-emerald-400/60' : ''}
`}>
- {audiobook.coverArtUrl ? (
+ {audiobook.coverArtUrl && !coverError ? (
setCoverError(true)}
/>
) : (
-
diff --git a/src/components/series/SeriesCard.tsx b/src/components/series/SeriesCard.tsx
index fc5614c..af6e1dc 100644
--- a/src/components/series/SeriesCard.tsx
+++ b/src/components/series/SeriesCard.tsx
@@ -9,7 +9,7 @@
'use client';
-import React from 'react';
+import React, { useState } from 'react';
import Image from 'next/image';
import Link from 'next/link';
import { SeriesSummary } from '@/lib/hooks/useSeries';
@@ -20,6 +20,7 @@ interface SeriesCardProps {
}
export function SeriesCard({ series, squareCovers = false }: SeriesCardProps) {
+ const [coverError, setCoverError] = useState(false);
const visibleTags = series.tags.slice(0, 2);
const hasTags = visibleTags.length > 0;
const hasRating = series.rating != null && series.rating > 0;
@@ -42,30 +43,23 @@ export function SeriesCard({ series, squareCovers = false }: SeriesCardProps) {
`}
>
{/* Cover Art or Fallback */}
- {series.coverArtUrl ? (
+ {series.coverArtUrl && !coverError ? (
-
+
+
+
+ {/* Footer */}
+
- {/* Section Content */}
-
- {/* Sticky Section Header */}
-
-
- {/* Call to Action */}
-
-
-
-
- {/* Footer */}
-
-
- {/* Unified Pagination — single context-aware pill for both sections */}
-
- popularSectionRef.current?.scrollIntoView({ behavior: 'smooth', block: 'start' }),
- },
- {
- label: 'New Releases',
- accentColor: 'bg-emerald-500',
- currentPage: newReleasesPage,
- totalPages: newReleasesTotalPages,
- onPageChange: handleNewReleasesPageChange,
- sectionRef: newReleasesSectionRef,
- onScrollToSection: () =>
- newReleasesSectionRef.current?.scrollIntoView({ behavior: 'smooth', block: 'start' }),
- },
- ]}
- />
+ {/* Config Modal */}
+ setConfigOpen(false)}
+ sections={sections}
+ onSave={saveSections}
+ />
);
diff --git a/src/components/audiobooks/AudiobookCard.tsx b/src/components/audiobooks/AudiobookCard.tsx
index 0afb173..f77048e 100644
--- a/src/components/audiobooks/AudiobookCard.tsx
+++ b/src/components/audiobooks/AudiobookCard.tsx
@@ -46,6 +46,8 @@ const getStatusConfig = (audiobook: Audiobook) => {
return null;
};
+const PLACEHOLDER_COVER = '/placeholder_cover.svg';
+
export function AudiobookCard({
audiobook,
onRequestSuccess,
@@ -57,6 +59,7 @@ export function AudiobookCard({
const [error, setError] = useState
-
-
+ {/* Loading state */}
+ {sectionsLoading && (
+ {
+ setPage(key, page);
+ ref.current?.scrollIntoView({ behavior: 'smooth', block: 'start' });
+ }}
+ sectionRef={ref}
+ cardSize={cardSize}
+ squareCovers={squareCovers}
hideAvailable={hideAvailable}
onToggleHideAvailable={setHideAvailable}
- squareCovers={squareCovers}
onToggleSquareCovers={setSquareCovers}
- cardSize={cardSize}
onCardSizeChange={setCardSize}
+ onConfigOpen={index === 0 ? () => setConfigOpen(true) : undefined}
+ onTotalPagesChange={(tp) => handleTotalPagesChange(key, tp)}
+ nextRefresh={nextRefresh}
/>
-
+ );
+ })}
+
+ {/* Call to Action */}
+ - Popular Audiobooks -
-
+
+
+ )}
+
+ {/* Empty state */}
+ {!sectionsLoading && sections.length === 0 && (
+
+
+ )}
+
+ {/* Dynamic sections */}
+ {!sectionsLoading &&
+ sections.map((section, index) => {
+ const key = getSectionKey(section);
+ const ref = sectionRefsMap.current.get(key)!;
+
+ return (
+ + No sections configured. Click Customize to add sections to your home page. +
+ ++ Can't find what you're looking for? +
++ Use our search to find any audiobook from Audible +
+ + Search Audiobooks + +
- {popularMessage && !loadingPopular && popular.length === 0 ? (
-
-
+ {/* Unified Pagination — dynamic sections */}
+ {paginationSections.length > 0 && (
+
-
- ) : (
- - No popular audiobooks found -
-- {popularMessage} -
-
-
-
- {/* Section Content */}
-
-
-
-
-
- - New Releases -
-
- {newReleasesMessage && !loadingNewReleases && newReleases.length === 0 ? (
-
-
-
- ) : (
- - No new releases found -
-- {newReleasesMessage} -
-- Can't find what you're looking for? -
-- Use our search to find any audiobook from Audible -
- - Search Audiobooks - -
-
-
+
-
-
+
{book.coverUrl ? (
+ /* eslint-disable-next-line @next/next/no-img-element */
{ (e.target as HTMLImageElement).src = '/placeholder_cover.svg'; }}
/>
) : (
setCoverError(true)}
/>
- ) : (
+ ) : isEbook ? (
diff --git a/src/components/bookdate/RecommendationCard.tsx b/src/components/bookdate/RecommendationCard.tsx
index 83a2ad1..cd02581 100644
--- a/src/components/bookdate/RecommendationCard.tsx
+++ b/src/components/bookdate/RecommendationCard.tsx
@@ -27,6 +27,7 @@ export function RecommendationCard({
isDraggable = true,
}: RecommendationCardProps) {
const [showToast, setShowToast] = useState(false);
+ const [coverError, setCoverError] = useState(false);
const [dragOffset, setDragOffset] = useState({ x: 0, y: 0 });
const [isDragging, setIsDragging] = useState(false);
@@ -227,7 +228,7 @@ export function RecommendationCard({
{/* Cover image - smaller on mobile to fit all content */}
;
+ cardSize: number;
+ squareCovers: boolean;
+ hideAvailable: boolean;
+ onToggleHideAvailable: (v: boolean) => void;
+ onToggleSquareCovers: (v: boolean) => void;
+ onCardSizeChange: (v: number) => void;
+ onConfigOpen?: () => void;
+ onTotalPagesChange?: (totalPages: number) => void;
+ nextRefresh: string | null;
+}
+
+function PopularOrNewSection({
+ type,
+ page,
+ hideAvailable,
+ onTotalPagesChange,
+ ...renderProps
+}: {
+ type: 'popular' | 'new-releases';
+ page: number;
+ hideAvailable: boolean;
+ onTotalPagesChange?: (totalPages: number) => void;
+} & RenderSectionProps) {
+ const { audiobooks, isLoading, totalPages, message } = useAudiobooks(type, 20, page, hideAvailable);
+
+ useEffect(() => {
+ onTotalPagesChange?.(totalPages);
+ }, [totalPages, onTotalPagesChange]);
+
+ return (
+
+ {/* Sticky Section Header */}
+
+ );
+}
diff --git a/src/components/home/HomeSectionConfigModal.tsx b/src/components/home/HomeSectionConfigModal.tsx
new file mode 100644
index 0000000..2072897
--- /dev/null
+++ b/src/components/home/HomeSectionConfigModal.tsx
@@ -0,0 +1,342 @@
+/**
+ * Component: Home Section Configuration Modal
+ * Documentation: documentation/features/home-sections.md
+ *
+ * Allows users to add/remove/reorder home page sections.
+ * Drag-and-drop on desktop, up/down arrows on mobile. Auto-save with debounce.
+ */
+
+'use client';
+
+import React, { useState, useEffect, useCallback, useRef } from 'react';
+import {
+ XMarkIcon,
+ PlusIcon,
+ TrashIcon,
+ ChevronUpIcon,
+ ChevronDownIcon,
+ Bars3Icon,
+} from '@heroicons/react/24/outline';
+import type { HomeSection, AudibleCategory } from '@/lib/hooks/useHomeSections';
+import { authenticatedFetcher } from '@/lib/utils/api';
+
+const MAX_SECTIONS = 10;
+
+const SECTION_COLORS = [
+ 'bg-blue-500', 'bg-emerald-500', 'bg-violet-500', 'bg-amber-500', 'bg-rose-500',
+ 'bg-cyan-500', 'bg-fuchsia-500', 'bg-lime-500', 'bg-orange-500', 'bg-teal-500',
+];
+
+function getSectionLabel(section: { sectionType: string; categoryName?: string | null }) {
+ if (section.sectionType === 'popular') return 'Popular Audiobooks';
+ if (section.sectionType === 'new_releases') return 'New Releases';
+ return section.categoryName || 'Category';
+}
+
+interface Props {
+ isOpen: boolean;
+ onClose: () => void;
+ sections: HomeSection[];
+ onSave: (sections: Omit[]) => Promise;
+}
+
+export function HomeSectionConfigModal({ isOpen, onClose, sections, onSave }: Props) {
+ const [localSections, setLocalSections] = useState[]>([]);
+ const [categories, setCategories] = useState([]);
+ const [loadingCategories, setLoadingCategories] = useState(false);
+ const [showCategoryPicker, setShowCategoryPicker] = useState(false);
+ const [saving, setSaving] = useState(false);
+ const [dirty, setDirty] = useState(false);
+ const debounceRef = useRef | null>(null);
+ const [dragIndex, setDragIndex] = useState(null);
+
+ // Sync from prop when modal opens
+ useEffect(() => {
+ if (isOpen) {
+ setLocalSections(
+ sections.map((s) => ({
+ sectionType: s.sectionType,
+ categoryId: s.categoryId,
+ categoryName: s.categoryName,
+ sortOrder: s.sortOrder,
+ }))
+ );
+ setDirty(false);
+ setShowCategoryPicker(false);
+ }
+ }, [isOpen, sections]);
+
+ // Auto-save with debounce
+ useEffect(() => {
+ if (!dirty) return;
+ if (debounceRef.current) clearTimeout(debounceRef.current);
+ debounceRef.current = setTimeout(async () => {
+ setSaving(true);
+ try {
+ await onSave(localSections.map((s, i) => ({ ...s, sortOrder: i })));
+ } catch {
+ // Silently fail — user will see stale state
+ }
+ setSaving(false);
+ setDirty(false);
+ }, 800);
+
+ return () => {
+ if (debounceRef.current) clearTimeout(debounceRef.current);
+ };
+ }, [dirty, localSections, onSave]);
+
+ // Fetch categories when picker opens
+ const loadCategories = useCallback(async () => {
+ if (categories.length > 0) {
+ setShowCategoryPicker(true);
+ return;
+ }
+ setLoadingCategories(true);
+ try {
+ const data = await authenticatedFetcher('/api/audible/categories');
+ setCategories(data.categories || []);
+ } catch {
+ setCategories([]);
+ }
+ setLoadingCategories(false);
+ setShowCategoryPicker(true);
+ }, [categories.length]);
+
+ const addCategory = useCallback(
+ (cat: AudibleCategory) => {
+ if (localSections.length >= MAX_SECTIONS) return;
+ // Prevent duplicate
+ if (localSections.some((s) => s.sectionType === 'category' && s.categoryId === cat.id)) return;
+
+ setLocalSections((prev) => [
+ ...prev,
+ {
+ sectionType: 'category' as const,
+ categoryId: cat.id,
+ categoryName: cat.name,
+ sortOrder: prev.length,
+ },
+ ]);
+ setDirty(true);
+ setShowCategoryPicker(false);
+ },
+ [localSections]
+ );
+
+ const addBuiltIn = useCallback(
+ (type: 'popular' | 'new_releases') => {
+ if (localSections.length >= MAX_SECTIONS) return;
+ if (localSections.some((s) => s.sectionType === type)) return;
+
+ setLocalSections((prev) => [
+ ...prev,
+ { sectionType: type, categoryId: null, categoryName: null, sortOrder: prev.length },
+ ]);
+ setDirty(true);
+ },
+ [localSections]
+ );
+
+ const removeSection = useCallback((index: number) => {
+ setLocalSections((prev) => prev.filter((_, i) => i !== index));
+ setDirty(true);
+ }, []);
+
+ const moveSection = useCallback((from: number, to: number) => {
+ setLocalSections((prev) => {
+ const next = [...prev];
+ const [item] = next.splice(from, 1);
+ next.splice(to, 0, item);
+ return next;
+ });
+ setDirty(true);
+ }, []);
+
+ // Drag handlers
+ const handleDragStart = (index: number) => {
+ setDragIndex(index);
+ };
+
+ const handleDragOver = (e: React.DragEvent, index: number) => {
+ e.preventDefault();
+ if (dragIndex === null || dragIndex === index) return;
+ moveSection(dragIndex, index);
+ setDragIndex(index);
+ };
+
+ const handleDragEnd = () => {
+ setDragIndex(null);
+ };
+
+ if (!isOpen) return null;
+
+ const hasPopular = localSections.some((s) => s.sectionType === 'popular');
+ const hasNewReleases = localSections.some((s) => s.sectionType === 'new_releases');
+ const existingCategoryIds = new Set(
+ localSections.filter((s) => s.sectionType === 'category').map((s) => s.categoryId)
+ );
+
+ return (
+ { (e.target as HTMLImageElement).src = '/placeholder_cover.svg'; }}
/>
))}
diff --git a/src/components/profile/WatchedListsSection.tsx b/src/components/profile/WatchedListsSection.tsx
index 48b16e2..efe5fbf 100644
--- a/src/components/profile/WatchedListsSection.tsx
+++ b/src/components/profile/WatchedListsSection.tsx
@@ -101,15 +101,14 @@ function WatchedSeriesCard({
{/* Cover */}
diff --git a/src/components/requests/RequestCard.tsx b/src/components/requests/RequestCard.tsx
index d54ad21..1c0784e 100644
--- a/src/components/requests/RequestCard.tsx
+++ b/src/components/requests/RequestCard.tsx
@@ -44,6 +44,7 @@ export function RequestCard({ request, showActions = true }: RequestCardProps) {
const { squareCovers } = usePreferences();
const [showError, setShowError] = React.useState(false);
const [showDetailsModal, setShowDetailsModal] = React.useState(false);
+ const [coverError, setCoverError] = React.useState(false);
const requestType = request.type || 'audiobook';
const isEbook = requestType === 'ebook';
@@ -98,41 +99,34 @@ export function RequestCard({ request, showActions = true }: RequestCardProps) {
tabIndex={request.audiobook.audibleAsin ? 0 : undefined}
onKeyDown={(e) => e.key === 'Enter' && request.audiobook.audibleAsin && setShowDetailsModal(true)}
>
- {request.audiobook.coverArtUrl ? (
+ {request.audiobook.coverArtUrl && !coverError ? (
- {recommendation.coverUrl ? (
+ {recommendation.coverUrl && !coverError ? (
setCoverError(true)}
/>
) : (
-
diff --git a/src/components/home/HomeSection.tsx b/src/components/home/HomeSection.tsx
new file mode 100644
index 0000000..c1981fa
--- /dev/null
+++ b/src/components/home/HomeSection.tsx
@@ -0,0 +1,310 @@
+/**
+ * Component: Home Section — renders a single audiobook discovery section
+ * Documentation: documentation/features/home-sections.md
+ *
+ * Handles popular, new_releases, and category section types with unified rendering.
+ */
+
+'use client';
+
+import React, { useEffect } from 'react';
+import { AudiobookGrid } from '@/components/audiobooks/AudiobookGrid';
+import { SectionToolbar } from '@/components/ui/SectionToolbar';
+import { useAudiobooks } from '@/lib/hooks/useAudiobooks';
+import { useCategoryAudiobooks } from '@/lib/hooks/useHomeSections';
+import { Cog6ToothIcon, ClockIcon } from '@heroicons/react/24/outline';
+
+const SECTION_COLORS = [
+ 'from-blue-500 to-indigo-500',
+ 'from-emerald-500 to-teal-500',
+ 'from-violet-500 to-purple-500',
+ 'from-amber-500 to-orange-500',
+ 'from-rose-500 to-pink-500',
+ 'from-cyan-500 to-sky-500',
+ 'from-fuchsia-500 to-pink-500',
+ 'from-lime-500 to-green-500',
+ 'from-orange-500 to-red-500',
+ 'from-teal-500 to-emerald-500',
+];
+
+export const SECTION_DOT_COLORS = [
+ 'bg-blue-500', 'bg-emerald-500', 'bg-violet-500', 'bg-amber-500', 'bg-rose-500',
+ 'bg-cyan-500', 'bg-fuchsia-500', 'bg-lime-500', 'bg-orange-500', 'bg-teal-500',
+];
+
+function getSectionTitle(sectionType: string, categoryName?: string | null): string {
+ if (sectionType === 'popular') return 'Popular Audiobooks';
+ if (sectionType === 'new_releases') return 'New Releases';
+ return categoryName || 'Category';
+}
+
+/**
+ * Formats a nextRefresh ISO timestamp into a friendly, readable string.
+ * Examples: "today at 6:00 PM", "tomorrow at 2:00 AM", "Saturday at 9:00 AM"
+ */
+function formatNextRefresh(isoString: string): string {
+ const refreshDate = new Date(isoString);
+ const now = new Date();
+
+ const refreshMidnight = new Date(refreshDate);
+ refreshMidnight.setHours(0, 0, 0, 0);
+
+ const todayMidnight = new Date(now);
+ todayMidnight.setHours(0, 0, 0, 0);
+
+ const tomorrowMidnight = new Date(todayMidnight);
+ tomorrowMidnight.setDate(tomorrowMidnight.getDate() + 1);
+
+ const dayAfterMidnight = new Date(tomorrowMidnight);
+ dayAfterMidnight.setDate(dayAfterMidnight.getDate() + 1);
+
+ const timeStr = refreshDate.toLocaleTimeString(undefined, {
+ hour: 'numeric',
+ minute: '2-digit',
+ hour12: true,
+ });
+
+ if (refreshMidnight.getTime() === todayMidnight.getTime()) {
+ return `today at ${timeStr}`;
+ }
+ if (refreshMidnight.getTime() === tomorrowMidnight.getTime()) {
+ return `tomorrow at ${timeStr}`;
+ }
+ if (refreshMidnight.getTime() < dayAfterMidnight.getTime()) {
+ const dayName = refreshDate.toLocaleDateString(undefined, { weekday: 'long' });
+ return `${dayName} at ${timeStr}`;
+ }
+
+ const dateStr = refreshDate.toLocaleDateString(undefined, {
+ weekday: 'long',
+ month: 'long',
+ day: 'numeric',
+ });
+ return `${dateStr} at ${timeStr}`;
+}
+
+interface HomeSectionProps {
+ sectionType: 'popular' | 'new_releases' | 'category';
+ categoryId: string | null;
+ categoryName: string | null;
+ colorIndex: number;
+ page: number;
+ onPageChange: (page: number) => void;
+ sectionRef: React.RefObject
- 📚
-
+
+
+ );
+}
+
+function RenderSection({
+ audiobooks,
+ isLoading,
+ totalPages,
+ message,
+ cardSize,
+ squareCovers,
+ nextRefresh,
+}: RenderSectionProps & {
+ audiobooks: any[];
+ isLoading: boolean;
+ totalPages: number;
+ message: string | null;
+}) {
+ if (message && !isLoading && audiobooks.length === 0) {
+ return
+
+ + No audiobooks yet +
++ {refreshLabel + ? <>This section will fill in after the next data refresh, scheduled for {refreshLabel}. + : 'This section will fill in after the next scheduled data refresh.'} +
+
+
+
+ {/* Section Content */}
+
+
+
+
+
+ + {title} +
+
+ {sectionType === 'popular' && (
+
+
+ {/* Backdrop */}
+
+
+ {/* Modal */}
+
+ );
+}
diff --git a/src/components/profile/GoodreadsShelvesSection.tsx b/src/components/profile/GoodreadsShelvesSection.tsx
index 0b8d5e5..df61352 100644
--- a/src/components/profile/GoodreadsShelvesSection.tsx
+++ b/src/components/profile/GoodreadsShelvesSection.tsx
@@ -333,12 +333,14 @@ function CoverStack({
onClick={() => book.asin && onBookClick(book.asin)}
title={book.asin ? `${book.title}${book.author ? ` by ${book.author}` : ''}` : undefined}
>
+ {/* eslint-disable-next-line @next/next/no-img-element */}
+ {/* Header */}
+
+
+
+
+ {/* Section list */}
+
+
+
+ + Customize Home +
++ {localSections.length}/{MAX_SECTIONS} sections + {saving && ( + Saving... + )} +
+
+ {localSections.length === 0 && (
+
+
+ {/* Add section controls */}
+
+
+ )}
+
+ {localSections.map((section, index) => (
+ No sections configured.
+Add sections below to customize your home page.
+ handleDragStart(index)}
+ onDragOver={(e) => handleDragOver(e, index)}
+ onDragEnd={handleDragEnd}
+ className={`
+ flex items-center gap-3 px-3 py-2.5 rounded-xl border transition-all duration-200
+ ${dragIndex === index
+ ? 'border-blue-400 dark:border-blue-500 bg-blue-50 dark:bg-blue-900/20 shadow-md scale-[1.02]'
+ : 'border-gray-200 dark:border-gray-700 bg-gray-50 dark:bg-gray-800/50 hover:border-gray-300 dark:hover:border-gray-600'
+ }
+ `}
+ >
+ {/* Drag handle */}
+
+ ))}
+
+
+
+ {/* Color dot */}
+
+
+ {/* Label */}
+
+ {getSectionLabel(section)}
+
+
+ {/* Mobile reorder arrows */}
+
+
+
+
+
+ {/* Remove */}
+
+
+ {/* Built-in section buttons */}
+
+
+ {!hasPopular && (
+
+ )}
+ {!hasNewReleases && (
+
+ )}
+
+
+
+ {/* Category picker */}
+ {showCategoryPicker && (
+
+ {categories.length === 0 ? (
+
+ )}
+ No categories found.
+ ) : (
+ categories
+ .filter((c) => !existingCategoryIds.has(c.id))
+ .map((cat) => (
+
+ ))
+ )}
+
+
- {isEbook ? (
-
- ) : (
-
- )}
+
+ ) : (
+
-
-
+
- {series.books[0]?.coverArtUrl ? (
+ {series.books[0]?.coverArtUrl && !coverError ? (
setCoverError(true)}
/>
) : (
-
-
-
+
- {s.coverArtUrl ? (
- { (e.target as HTMLImageElement).src = '/placeholder_cover.svg'; }}
+ />
{/* Title */}
diff --git a/src/components/ui/UnifiedPagination.tsx b/src/components/ui/UnifiedPagination.tsx
index b44230b..6fd0b07 100644
--- a/src/components/ui/UnifiedPagination.tsx
+++ b/src/components/ui/UnifiedPagination.tsx
@@ -2,10 +2,9 @@
* Component: Unified Pagination — context-aware floating paginator
* Documentation: documentation/frontend/components.md
*
- * Replaces two overlapping StickyPagination instances with a single pill
- * that automatically tracks which section dominates the viewport and shows
- * controls for that section. Transitions smoothly when the dominant section
- * changes. Includes a two-dot section indicator for manual switching.
+ * A single floating pill that automatically tracks which section dominates
+ * the viewport and shows pagination controls for that section.
+ * Supports 1-12 sections dynamically with dot indicators for manual switching.
*/
'use client';
@@ -28,7 +27,7 @@ export interface PaginationSection {
}
interface UnifiedPaginationProps {
- sections: [PaginationSection, PaginationSection];
+ sections: PaginationSection[];
footerRef?: React.RefObject
-
- {s.title.charAt(0).toUpperCase()}
-
-
- )}
+
+ {sections.map((section, idx) => {
+ const isActive = idx === activeIndex;
+ return (
+
+ );
+ }
+
+ // ---- Many sections: windowed 5-slot strip ----
+ // The window is always 5 slots wide; we clamp it so it doesn't fall off edges.
+ const WINDOW = 5;
+ const half = Math.floor(WINDOW / 2); // 2
+
+ // Ideal window start: center the active dot
+ let windowStart = activeIndex - half;
+ // Clamp so window stays within [0, count - WINDOW]
+ windowStart = Math.max(0, Math.min(windowStart, count - WINDOW));
+ const windowEnd = windowStart + WINDOW - 1; // inclusive
+
+ // Distance from active within the window (for size calculation)
+ // slots: [windowStart, windowStart+1, ..., windowEnd]
+ const slots = Array.from({ length: WINDOW }, (_, i) => windowStart + i);
+
+ // Sizes: index 0 (dist 2 from active) → 2.5px, dist 1 → 4px, dist 0 (active) → 6px
+ const heightForDist = [16, 10, 7, 5, 3]; // px — dist 0..4 (we only use 0-2)
+
+ // Whether we need overflow arrows (dots hidden beyond window edges)
+ const hasHiddenLeft = windowStart > 0;
+ const hasHiddenRight = windowEnd < count - 1;
+
+ return (
+
+ {/* Top fade indicator */}
+ {hasHiddenLeft && (
+
+ )}
+
+ {slots.map((sectionIdx) => {
+ const section = sections[sectionIdx];
+ const isActive = sectionIdx === activeIndex;
+ const dist = Math.abs(sectionIdx - activeIndex);
+ const h = heightForDist[Math.min(dist, heightForDist.length - 1)];
+
+ // Active dot gets the section's accent color.
+ // Inactive dots: the farther they are, the more faded.
+ const opacityMap = [1, 0.55, 0.3];
+ const opacity = opacityMap[Math.min(dist, opacityMap.length - 1)];
+
+ return (
+
+ );
+}
+
// ---------------------------------------------------------------------------
// Main component
// ---------------------------------------------------------------------------
export function UnifiedPagination({ sections, footerRef }: UnifiedPaginationProps) {
- // Index of the currently dominant section (0 or 1)
- const [activeIndex, setActiveIndex] = useState<0 | 1>(0);
- // Whether the label+controls area is mid-transition (drives opacity fade)
+ const [activeIndex, setActiveIndex] = useState(0);
const [isTransitioning, setIsTransitioning] = useState(false);
-
const [footerVisible, setFooterVisible] = useState(false);
- // Per-section raw intersection ratios [0,1]
- const ratiosRef = useRef<[number, number]>([0, 0]);
- // Whether each section has any meaningful intersection
- const [sectionVisible, setSectionVisible] = useState<[boolean, boolean]>([false, false]);
+ const ratiosRef = useRef
- {sections.map((section, idx) => {
- const isActive = idx === activeIndex;
- return (
-
+ {sections.length > 1 && (
+ <>
+
{/* Section label — hidden on small screens */}
-
+
{active.label}
diff --git a/src/lib/hooks/useHomeSections.ts b/src/lib/hooks/useHomeSections.ts
new file mode 100644
index 0000000..9567a71
--- /dev/null
+++ b/src/lib/hooks/useHomeSections.ts
@@ -0,0 +1,119 @@
+/**
+ * Component: Home Sections Hook
+ * Documentation: documentation/features/home-sections.md
+ *
+ * Manages user home section configuration (CRUD) and category fetching.
+ */
+
+'use client';
+
+import useSWR, { mutate as globalMutate } from 'swr';
+import { authenticatedFetcher } from '@/lib/utils/api';
+import { useCallback, useRef } from 'react';
+
+export interface HomeSection {
+ id: string;
+ sectionType: 'popular' | 'new_releases' | 'category';
+ categoryId: string | null;
+ categoryName: string | null;
+ sortOrder: number;
+}
+
+export interface HomeSectionsResponse {
+ success: boolean;
+ sections: HomeSection[];
+ nextRefresh: string | null;
+}
+
+export interface AudibleCategory {
+ id: string;
+ name: string;
+}
+
+const HOME_SECTIONS_KEY = '/api/user/home-sections';
+
+/**
+ * Hook to fetch and manage user home sections.
+ */
+export function useHomeSections() {
+ const { data, error, isLoading, mutate } = useSWR(
+ HOME_SECTIONS_KEY,
+ authenticatedFetcher,
+ {
+ revalidateOnFocus: false,
+ dedupingInterval: 30000,
+ }
+ );
+
+ const saveSections = useCallback(
+ async (sections: Omit[]) => {
+ const { fetchJSON } = await import('@/lib/utils/api');
+ const result = await fetchJSON(HOME_SECTIONS_KEY, {
+ method: 'PUT',
+ body: JSON.stringify({ sections }),
+ });
+ // Update local cache
+ mutate(result, false);
+ return result;
+ },
+ [mutate]
+ );
+
+ return {
+ sections: data?.sections || [],
+ nextRefresh: data?.nextRefresh || null,
+ isLoading,
+ error,
+ saveSections,
+ mutate,
+ };
+}
+
+/**
+ * Hook to fetch Audible categories (live scrape, for config modal).
+ */
+export function useAudibleCategories() {
+ const { data, error, isLoading } = useSWR<{ success: boolean; categories: AudibleCategory[] }>(
+ null, // Don't fetch automatically — use fetchCategories
+ authenticatedFetcher,
+ { revalidateOnFocus: false }
+ );
+
+ return {
+ categories: data?.categories || [],
+ isLoading,
+ error,
+ };
+}
+
+/**
+ * Hook to fetch category audiobooks (same pattern as useAudiobooks).
+ */
+export function useCategoryAudiobooks(
+ categoryId: string | null,
+ limit: number = 20,
+ page: number = 1,
+ hideAvailable: boolean = false
+) {
+ const hideParam = hideAvailable ? '&hideAvailable=true' : '';
+ const endpoint = categoryId
+ ? `/api/audiobooks/category/${categoryId}?page=${page}&limit=${limit}${hideParam}`
+ : null;
+
+ const { data, error, isLoading } = useSWR(endpoint, authenticatedFetcher, {
+ revalidateOnFocus: false,
+ revalidateOnReconnect: false,
+ dedupingInterval: 60000,
+ });
+
+ return {
+ audiobooks: data?.audiobooks || [],
+ totalCount: data?.totalCount || 0,
+ totalPages: data?.totalPages || 0,
+ currentPage: data?.page || page,
+ hasMore: data?.hasMore || false,
+ message: data?.message || null,
+ isLoading,
+ error,
+ };
+}
diff --git a/src/lib/integrations/audible.service.ts b/src/lib/integrations/audible.service.ts
index de32076..bc1bd90 100644
--- a/src/lib/integrations/audible.service.ts
+++ b/src/lib/integrations/audible.service.ts
@@ -256,6 +256,15 @@ export class AudibleService {
throw error;
}
+ // Don't retry on deterministic 500 errors (e.g. "Release date is in the future")
+ if (status === 500) {
+ const message = error.response?.data?.message || '';
+ if (message.includes('Release date is in the future')) {
+ logger.info(` External API returned non-retryable error: ${message}`);
+ throw error;
+ }
+ }
+
// Don't retry on last attempt
if (attempt === maxRetries) {
break;
@@ -1172,6 +1181,155 @@ export class AudibleService {
}
}
+ /**
+ * Get top-level categories from Audible's categories page.
+ * Scrapes {baseUrl}/categories and returns {id, name}[] for top-level nodes.
+ */
+ async getCategories(): Promise<{ id: string; name: string }[]> {
+ await this.initialize();
+
+ logger.info('Fetching Audible categories...');
+
+ try {
+ const { data: response } = await this.fetchWithRetry('/categories', {
+ params: { ipRedirectOverride: 'true' },
+ });
+
+ const $ = cheerio.load(response.data);
+ const categories: { id: string; name: string }[] = [];
+
+ // Top-level category links are in the main categories grid
+ // They follow the pattern /cat/{name}/{nodeId}
+ $('a[href*="/cat/"]').each((_index, element) => {
+ const $el = $(element);
+ const href = $el.attr('href') || '';
+ const match = href.match(/\/cat\/[^\/]+\/(\d+)/);
+ if (!match) return;
+
+ const id = match[1];
+ const name = $el.text().trim();
+
+ if (name && !categories.some((c) => c.id === id)) {
+ categories.push({ id, name });
+ }
+ });
+
+ logger.info(`Found ${categories.length} top-level categories`);
+ return categories;
+ } catch (error) {
+ logger.error('Failed to fetch categories', {
+ error: error instanceof Error ? error.message : String(error),
+ });
+ return [];
+ }
+ }
+
+ /**
+ * Get audiobooks for a specific category using Audible search with node parameter.
+ * Scrapes {baseUrl}/search?node={categoryId}&pageSize=50, up to `limit` results.
+ */
+ async getCategoryBooks(categoryId: string, limit: number = 200): Promise {
+ await this.initialize();
+
+ logger.info(`Fetching category books for node ${categoryId} (limit: ${limit})...`);
+
+ const audiobooks: AudibleAudiobook[] = [];
+ let page = 1;
+ const maxPages = Math.ceil(limit / AUDIBLE_PAGE_SIZE);
+
+ this.pacer.reset();
+
+ while (audiobooks.length < limit && page <= maxPages) {
+ try {
+ const { data: response, meta } = await this.fetchWithRetry('/search', {
+ params: {
+ ipRedirectOverride: 'true',
+ node: categoryId,
+ pageSize: AUDIBLE_PAGE_SIZE,
+ sort: 'popularity-rank',
+ ...(page > 1 ? { page } : {}),
+ },
+ });
+
+ const $ = cheerio.load(response.data);
+ let foundOnPage = 0;
+
+ // Parse search results — same selectors as search()
+ $('.s-result-item, .productListItem').each((_index, element) => {
+ if (audiobooks.length >= limit) return false;
+ const $el = $(element);
+
+ const asin =
+ $el.find('li').attr('data-asin') ||
+ $el.find('a').attr('href')?.match(/\/(?:pd|ac)\/[^\/]+\/([A-Z0-9]{10})/)?.[1] ||
+ '';
+ if (!asin || audiobooks.some((b) => b.asin === asin)) return;
+
+ const title =
+ $el.find('h2').first().text().trim() ||
+ $el.find('h3 a').text().trim() ||
+ $el.find('.bc-heading a').text().trim();
+
+ const authorLink = $el.find('a[href*="/author/"]').first();
+ const authorText =
+ authorLink.text().trim() ||
+ $el.find('.authorLabel').text().trim();
+ const authorHref = authorLink.attr('href') || '';
+ const authorAsinMatch = authorHref.match(/\/author\/[^\/]+\/([A-Z0-9]{10})/);
+
+ const narratorText =
+ $el.find('a[href*="searchNarrator="]').first().text().trim() ||
+ $el.find('.narratorLabel').text().trim();
+
+ const coverArtUrl = $el.find('img').attr('src') || '';
+
+ const langConfig = this.getLangConfig();
+ const runtimeText =
+ $el.find('.runtimeLabel').text().trim() ||
+ $el.find(buildContainsSelector('span', langConfig.scraping.lengthLabels)).text().trim();
+ const durationMinutes = this.parseRuntime(runtimeText);
+
+ const ratingText =
+ $el.find('.ratingsLabel').text().trim() ||
+ $el.find('.a-icon-star span').first().text().trim();
+ const rating = ratingText ? parseFloat(ratingText.split(' ')[0]) : undefined;
+
+ audiobooks.push({
+ asin,
+ title,
+ author: stripPrefixes(authorText, langConfig.scraping.authorPrefixes),
+ authorAsin: authorAsinMatch?.[1] || undefined,
+ narrator: stripPrefixes(narratorText, langConfig.scraping.narratorPrefixes),
+ coverArtUrl: coverArtUrl.replace(/\._.*_\./, '._SL500_.'),
+ durationMinutes,
+ rating,
+ });
+
+ foundOnPage++;
+ });
+
+ logger.info(`Category ${categoryId}: found ${foundOnPage} books on page ${page}`);
+
+ if (foundOnPage < AUDIBLE_PAGE_SIZE / 2) break;
+
+ page++;
+
+ if (page <= maxPages && audiobooks.length < limit) {
+ await this.delay(this.pacer.reportPageResult(meta));
+ }
+ } catch (error) {
+ logger.error(`Failed to fetch category ${categoryId} page ${page}`, {
+ error: error instanceof Error ? error.message : String(error),
+ collectedSoFar: audiobooks.length,
+ });
+ break;
+ }
+ }
+
+ logger.info(`Category ${categoryId}: collected ${audiobooks.length} books across ${page - 1} pages`);
+ return audiobooks;
+ }
+
/**
* Add delay between requests to respect rate limits
*/
diff --git a/src/lib/processors/audible-refresh.processor.ts b/src/lib/processors/audible-refresh.processor.ts
index 817d831..0c15bee 100644
--- a/src/lib/processors/audible-refresh.processor.ts
+++ b/src/lib/processors/audible-refresh.processor.ts
@@ -2,12 +2,18 @@
* Component: Audible Refresh Processor
* Documentation: documentation/backend/services/scheduler.md
*
- * Fetches popular and new release audiobooks from Audible and caches them
+ * Fetches popular, new release, and category audiobooks from Audible and caches them.
+ * All section data is stored uniformly in AudibleCacheCategory with reserved IDs
+ * '__popular__' and '__new_releases__' for built-in sections.
*/
import { prisma } from '../db';
import { RMABLogger } from '../utils/logger';
+/** Reserved category IDs for built-in home sections */
+export const POPULAR_CATEGORY_ID = '__popular__';
+export const NEW_RELEASES_CATEGORY_ID = '__new_releases__';
+
export interface AudibleRefreshPayload {
jobId?: string;
scheduledJobId?: string;
@@ -25,22 +31,7 @@ export async function processAudibleRefresh(payload: AudibleRefreshPayload): Pro
const thumbnailCache = getThumbnailCacheService();
try {
- // Clear previous popular/new-release flags for fresh data
- await prisma.audibleCache.updateMany({
- where: {
- OR: [
- { isPopular: true },
- { isNewRelease: true },
- ],
- },
- data: {
- isPopular: false,
- isNewRelease: false,
- popularRank: null,
- newReleaseRank: null,
- },
- });
- logger.info('Cleared previous popular/new-release flags in audible_cache');
+ const syncTime = new Date();
// Fetch popular and new releases - 200 items each
const popular = await audibleService.getPopularAudiobooks(200);
@@ -54,113 +45,63 @@ export async function processAudibleRefresh(payload: AudibleRefreshPayload): Pro
logger.info(`Fetched ${popular.length} popular, ${newReleases.length} new releases from Audible`);
- // Persist to audible_cache
- let popularSaved = 0;
- let newReleasesSaved = 0;
- const syncTime = new Date();
+ // Persist popular audiobooks via AudibleCacheCategory
+ const popularSaved = await persistSectionBooks(
+ popular, POPULAR_CATEGORY_ID, syncTime, thumbnailCache, logger, 'popular audiobook'
+ );
- for (let i = 0; i < popular.length; i++) {
- const audiobook = popular[i];
- try {
- // Cache thumbnail if coverArtUrl exists
- let cachedCoverPath: string | null = null;
- if (audiobook.coverArtUrl) {
- cachedCoverPath = await thumbnailCache.cacheThumbnail(audiobook.asin, audiobook.coverArtUrl);
+ // Persist new releases via AudibleCacheCategory
+ const newReleasesSaved = await persistSectionBooks(
+ newReleases, NEW_RELEASES_CATEGORY_ID, syncTime, thumbnailCache, logger, 'new release'
+ );
+
+ logger.info(`Saved ${popularSaved} popular and ${newReleasesSaved} new releases`);
+
+ // --- Category scraping ---
+ // Query distinct categoryIds from all users' home sections
+ let categoriesSynced = 0;
+ try {
+ const categorySections = await prisma.userHomeSection.findMany({
+ where: { sectionType: 'category', categoryId: { not: null } },
+ select: { categoryId: true },
+ distinct: ['categoryId'],
+ });
+
+ const categoryIds = categorySections
+ .map((s) => s.categoryId)
+ .filter((id): id is string => id !== null);
+
+ if (categoryIds.length > 0) {
+ logger.info(`Refreshing ${categoryIds.length} user-configured categories...`);
+
+ for (const catId of categoryIds) {
+ try {
+ // Batch cooldown between categories
+ const catCooldownMs = 10000 + Math.floor(Math.random() * 10000);
+ logger.info(`Category cooldown: waiting ${Math.round(catCooldownMs / 1000)}s before category ${catId}...`);
+ await new Promise(resolve => setTimeout(resolve, catCooldownMs));
+
+ // Scrape category books
+ const books = await audibleService.getCategoryBooks(catId, 200);
+ logger.info(`Category ${catId}: fetched ${books.length} books`);
+
+ const saved = await persistSectionBooks(
+ books, catId, syncTime, thumbnailCache, logger, 'category book'
+ );
+
+ categoriesSynced++;
+ logger.info(`Category ${catId}: saved ${saved} entries`);
+ } catch (error) {
+ logger.error(`Failed to refresh category ${catId}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
}
- await prisma.audibleCache.upsert({
- where: { asin: audiobook.asin },
- create: {
- asin: audiobook.asin,
- title: audiobook.title,
- author: audiobook.author,
- narrator: audiobook.narrator,
- description: audiobook.description,
- coverArtUrl: audiobook.coverArtUrl,
- cachedCoverPath: cachedCoverPath,
- durationMinutes: audiobook.durationMinutes,
- releaseDate: audiobook.releaseDate ? new Date(audiobook.releaseDate) : null,
- rating: audiobook.rating ? audiobook.rating : null,
- genres: audiobook.genres || [],
- isPopular: true,
- popularRank: i + 1,
- lastSyncedAt: syncTime,
- },
- update: {
- title: audiobook.title,
- author: audiobook.author,
- narrator: audiobook.narrator,
- description: audiobook.description,
- coverArtUrl: audiobook.coverArtUrl,
- cachedCoverPath: cachedCoverPath,
- durationMinutes: audiobook.durationMinutes,
- releaseDate: audiobook.releaseDate ? new Date(audiobook.releaseDate) : null,
- rating: audiobook.rating ? audiobook.rating : null,
- genres: audiobook.genres || [],
- isPopular: true,
- popularRank: i + 1,
- lastSyncedAt: syncTime,
- },
- });
-
- popularSaved++;
- } catch (error) {
- logger.error(`Failed to save popular audiobook ${audiobook.title}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+ logger.info(`Category refresh complete: ${categoriesSynced}/${categoryIds.length} categories synced`);
}
+ } catch (error) {
+ logger.error(`Category refresh failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
}
- for (let i = 0; i < newReleases.length; i++) {
- const audiobook = newReleases[i];
- try {
- // Cache thumbnail if coverArtUrl exists
- let cachedCoverPath: string | null = null;
- if (audiobook.coverArtUrl) {
- cachedCoverPath = await thumbnailCache.cacheThumbnail(audiobook.asin, audiobook.coverArtUrl);
- }
-
- await prisma.audibleCache.upsert({
- where: { asin: audiobook.asin },
- create: {
- asin: audiobook.asin,
- title: audiobook.title,
- author: audiobook.author,
- narrator: audiobook.narrator,
- description: audiobook.description,
- coverArtUrl: audiobook.coverArtUrl,
- cachedCoverPath: cachedCoverPath,
- durationMinutes: audiobook.durationMinutes,
- releaseDate: audiobook.releaseDate ? new Date(audiobook.releaseDate) : null,
- rating: audiobook.rating ? audiobook.rating : null,
- genres: audiobook.genres || [],
- isNewRelease: true,
- newReleaseRank: i + 1,
- lastSyncedAt: syncTime,
- },
- update: {
- title: audiobook.title,
- author: audiobook.author,
- narrator: audiobook.narrator,
- description: audiobook.description,
- coverArtUrl: audiobook.coverArtUrl,
- cachedCoverPath: cachedCoverPath,
- durationMinutes: audiobook.durationMinutes,
- releaseDate: audiobook.releaseDate ? new Date(audiobook.releaseDate) : null,
- rating: audiobook.rating ? audiobook.rating : null,
- genres: audiobook.genres || [],
- isNewRelease: true,
- newReleaseRank: i + 1,
- lastSyncedAt: syncTime,
- },
- });
-
- newReleasesSaved++;
- } catch (error) {
- logger.error(`Failed to save new release ${audiobook.title}: ${error instanceof Error ? error.message : 'Unknown error'}`);
- }
- }
-
- logger.info(`Saved ${popularSaved} popular and ${newReleasesSaved} new releases to audible_cache`);
-
// Cleanup unused thumbnails
logger.info('Cleaning up unused thumbnails...');
const allActiveAsins = await prisma.audibleCache.findMany({
@@ -175,6 +116,7 @@ export async function processAudibleRefresh(payload: AudibleRefreshPayload): Pro
message: 'Audible refresh completed',
popularSaved,
newReleasesSaved,
+ categoriesSynced,
thumbnailsDeleted: deletedCount,
};
} catch (error) {
@@ -182,3 +124,87 @@ export async function processAudibleRefresh(payload: AudibleRefreshPayload): Pro
throw error;
}
}
+
+/**
+ * Wipe previous entries for a category, upsert book metadata into AudibleCache,
+ * and insert ranked entries into AudibleCacheCategory.
+ * Returns the number of books successfully saved.
+ */
+async function persistSectionBooks(
+ books: any[],
+ categoryId: string,
+ syncTime: Date,
+ thumbnailCache: { cacheThumbnail: (asin: string, url: string) => Promise },
+ logger: ReturnType,
+ labelForErrors: string,
+): Promise {
+ // Wipe previous entries for this section
+ logger.info(`Clearing previous data for ${categoryId}...`);
+ await prisma.audibleCacheCategory.deleteMany({
+ where: { categoryId },
+ });
+ logger.info(`Cleared previous entries for ${categoryId}, saving ${books.length} books...`);
+
+ let saved = 0;
+ for (let i = 0; i < books.length; i++) {
+ const book = books[i];
+ try {
+ // Cache thumbnail if coverArtUrl exists
+ let cachedCoverPath: string | null = null;
+ if (book.coverArtUrl) {
+ cachedCoverPath = await thumbnailCache.cacheThumbnail(book.asin, book.coverArtUrl);
+ if (!cachedCoverPath) {
+ logger.warn(`Cover cache failed for "${book.title}" (${book.asin}) - falling back to remote URL`);
+ }
+ }
+
+ // Upsert book metadata into AudibleCache
+ await prisma.audibleCache.upsert({
+ where: { asin: book.asin },
+ create: {
+ asin: book.asin,
+ title: book.title,
+ author: book.author,
+ narrator: book.narrator,
+ description: book.description,
+ coverArtUrl: book.coverArtUrl,
+ cachedCoverPath,
+ durationMinutes: book.durationMinutes,
+ releaseDate: book.releaseDate ? new Date(book.releaseDate) : null,
+ rating: book.rating ? book.rating : null,
+ genres: book.genres || [],
+ lastSyncedAt: syncTime,
+ },
+ update: {
+ title: book.title,
+ author: book.author,
+ narrator: book.narrator,
+ description: book.description,
+ coverArtUrl: book.coverArtUrl,
+ cachedCoverPath,
+ durationMinutes: book.durationMinutes,
+ releaseDate: book.releaseDate ? new Date(book.releaseDate) : null,
+ rating: book.rating ? book.rating : null,
+ genres: book.genres || [],
+ lastSyncedAt: syncTime,
+ },
+ });
+
+ // Insert ranked entry into AudibleCacheCategory
+ await prisma.audibleCacheCategory.create({
+ data: {
+ asin: book.asin,
+ categoryId,
+ rank: i + 1,
+ lastSyncedAt: syncTime,
+ },
+ });
+
+ saved++;
+ } catch (error) {
+ logger.error(`Failed to save ${labelForErrors} ${book.title}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ return saved;
+}
diff --git a/src/lib/services/thumbnail-cache.service.ts b/src/lib/services/thumbnail-cache.service.ts
index 8673768..7bfb4b7 100644
--- a/src/lib/services/thumbnail-cache.service.ts
+++ b/src/lib/services/thumbnail-cache.service.ts
@@ -24,7 +24,7 @@ export class ThumbnailCacheService {
try {
await fs.mkdir(CACHE_DIR, { recursive: true });
} catch (error) {
- logger.error('Failed to create cache directory', { error: error instanceof Error ? error.message : String(error) });
+ logger.error(`Failed to create cache directory: ${error instanceof Error ? error.message : String(error)}`);
throw error;
}
}
@@ -36,7 +36,7 @@ export class ThumbnailCacheService {
try {
await fs.mkdir(LIBRARY_CACHE_DIR, { recursive: true });
} catch (error) {
- logger.error('Failed to create library cache directory', { error: error instanceof Error ? error.message : String(error) });
+ logger.error(`Failed to create library cache directory: ${error instanceof Error ? error.message : String(error)}`);
throw error;
}
}
@@ -127,8 +127,8 @@ export class ThumbnailCacheService {
logger.info(`Cached thumbnail for ${asin}: ${filePath}`);
return filePath;
} catch (error) {
- // Log error but don't throw - we'll fall back to the original URL
- logger.error(`Failed to cache thumbnail for ${asin}`, { error: error instanceof Error ? error.message : String(error) });
+ // Log warning but don't throw - we'll fall back to the original URL
+ logger.warn(`Failed to cache thumbnail for ${asin}: ${error instanceof Error ? error.message : String(error)} - will use remote URL`);
return null;
}
}
@@ -203,10 +203,8 @@ export class ThumbnailCacheService {
logger.info(`Cached library thumbnail for ${plexGuid}: ${filePath}`);
return filePath;
} catch (error) {
- // Log error but don't throw - graceful degradation
- logger.warn(`Failed to cache library thumbnail for ${plexGuid}`, {
- error: error instanceof Error ? error.message : String(error),
- });
+ // Log warning but don't throw - graceful degradation
+ logger.warn(`Failed to cache library thumbnail for ${plexGuid}: ${error instanceof Error ? error.message : String(error)}`);
return null;
}
}
@@ -227,7 +225,7 @@ export class ThumbnailCacheService {
logger.info(`Deleted thumbnail: ${filePath}`);
}
} catch (error) {
- logger.error(`Failed to delete thumbnail for ${asin}`, { error: error instanceof Error ? error.message : String(error) });
+ logger.error(`Failed to delete thumbnail for ${asin}: ${error instanceof Error ? error.message : String(error)}`);
}
}
@@ -258,7 +256,7 @@ export class ThumbnailCacheService {
logger.info(`Cleanup complete: ${deletedCount} thumbnails deleted`);
return deletedCount;
} catch (error) {
- logger.error('Failed to cleanup thumbnails', { error: error instanceof Error ? error.message : String(error) });
+ logger.error(`Failed to cleanup thumbnails: ${error instanceof Error ? error.message : String(error)}`);
return 0;
}
}
@@ -299,9 +297,7 @@ export class ThumbnailCacheService {
logger.info(`Library cleanup complete: ${deletedCount} thumbnails deleted`);
return deletedCount;
} catch (error) {
- logger.error('Failed to cleanup library thumbnails', {
- error: error instanceof Error ? error.message : String(error),
- });
+ logger.error(`Failed to cleanup library thumbnails: ${error instanceof Error ? error.message : String(error)}`);
return 0;
}
}
diff --git a/tests/api/audiobooks-browse.routes.test.ts b/tests/api/audiobooks-browse.routes.test.ts
index 9ffe21c..f4f5e24 100644
--- a/tests/api/audiobooks-browse.routes.test.ts
+++ b/tests/api/audiobooks-browse.routes.test.ts
@@ -68,6 +68,12 @@ describe('Audiobooks browse routes', () => {
});
it('returns popular audiobooks with cached cover URLs', async () => {
+ // Mock AudibleCacheCategory query (popular route now queries category table)
+ prismaMock.audibleCacheCategory.findMany.mockResolvedValueOnce([
+ { asin: 'ASIN', rank: 1 },
+ ]);
+ prismaMock.audibleCacheCategory.count.mockResolvedValueOnce(1);
+ // Mock AudibleCache metadata fetch
prismaMock.audibleCache.findMany.mockResolvedValueOnce([
{
asin: 'ASIN',
@@ -84,7 +90,6 @@ describe('Audiobooks browse routes', () => {
lastSyncedAt: new Date(),
},
]);
- prismaMock.audibleCache.count.mockResolvedValueOnce(1);
enrichMock.mockResolvedValueOnce([{ asin: 'ASIN', coverArtUrl: '/api/cache/thumbnails/asin.jpg' }]);
const { GET } = await import('@/app/api/audiobooks/popular/route');
@@ -106,8 +111,9 @@ describe('Audiobooks browse routes', () => {
});
it('returns new release audiobooks', async () => {
- prismaMock.audibleCache.findMany.mockResolvedValueOnce([]);
- prismaMock.audibleCache.count.mockResolvedValueOnce(0);
+ // Mock AudibleCacheCategory query (new-releases route now queries category table)
+ prismaMock.audibleCacheCategory.findMany.mockResolvedValueOnce([]);
+ prismaMock.audibleCacheCategory.count.mockResolvedValueOnce(0);
const { GET } = await import('@/app/api/audiobooks/new-releases/route');
const response = await GET({ nextUrl: new URL('http://app/api/audiobooks/new-releases?page=1&limit=1') } as any);
@@ -118,6 +124,12 @@ describe('Audiobooks browse routes', () => {
});
it('enriches new releases and uses cached cover URLs', async () => {
+ // Mock AudibleCacheCategory query
+ prismaMock.audibleCacheCategory.findMany.mockResolvedValueOnce([
+ { asin: 'ASIN', rank: 1 },
+ ]);
+ prismaMock.audibleCacheCategory.count.mockResolvedValueOnce(1);
+ // Mock AudibleCache metadata fetch
prismaMock.audibleCache.findMany.mockResolvedValueOnce([
{
asin: 'ASIN',
@@ -134,7 +146,6 @@ describe('Audiobooks browse routes', () => {
lastSyncedAt: new Date('2024-01-02'),
},
]);
- prismaMock.audibleCache.count.mockResolvedValueOnce(1);
currentUserMock.mockReturnValue({ sub: 'user-1' });
enrichMock.mockResolvedValueOnce([{ asin: 'ASIN', available: true }]);
@@ -155,7 +166,7 @@ describe('Audiobooks browse routes', () => {
});
it('returns 500 when new releases query fails', async () => {
- prismaMock.audibleCache.findMany.mockRejectedValueOnce(new Error('db down'));
+ prismaMock.audibleCacheCategory.findMany.mockRejectedValueOnce(new Error('db down'));
const { GET } = await import('@/app/api/audiobooks/new-releases/route');
const response = await GET({ nextUrl: new URL('http://app/api/audiobooks/new-releases?page=1&limit=1') } as any);
@@ -209,6 +220,11 @@ describe('Audiobooks browse routes', () => {
});
it('returns cached covers for login', async () => {
+ // Mock AudibleCacheCategory query (covers route now queries category table)
+ prismaMock.audibleCacheCategory.findMany.mockResolvedValueOnce([
+ { asin: 'ASIN' },
+ ]);
+ // Mock AudibleCache metadata fetch
prismaMock.audibleCache.findMany.mockResolvedValueOnce([
{ asin: 'ASIN', title: 'Title', author: 'Author', cachedCoverPath: '/tmp/asin.jpg', coverArtUrl: null },
]);
@@ -221,5 +237,3 @@ describe('Audiobooks browse routes', () => {
expect(payload.covers[0].coverUrl).toBe('/api/cache/thumbnails/asin.jpg');
});
});
-
-
diff --git a/tests/api/home-sections.routes.test.ts b/tests/api/home-sections.routes.test.ts
new file mode 100644
index 0000000..22ce3e7
--- /dev/null
+++ b/tests/api/home-sections.routes.test.ts
@@ -0,0 +1,166 @@
+/**
+ * Component: Home Sections API Route Tests
+ * Documentation: documentation/features/home-sections.md
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createPrismaMock } from '../helpers/prisma';
+
+const prismaMock = createPrismaMock();
+
+vi.mock('@/lib/db', () => ({
+ prisma: prismaMock,
+}));
+
+vi.mock('@/lib/middleware/auth', () => ({
+ requireAuth: vi.fn((_req: any, handler: any) => {
+ const mockReq = {
+ user: { id: 'user-1', sub: 'user-1', role: 'user' },
+ json: async () => (globalThis as any).__testBody || {},
+ };
+ return handler(mockReq);
+ }),
+ getCurrentUser: vi.fn(() => ({ sub: 'user-1' })),
+}));
+
+vi.mock('@/lib/utils/logger', () => ({
+ RMABLogger: { create: () => ({ info: vi.fn(), error: vi.fn(), warn: vi.fn(), debug: vi.fn() }) },
+}));
+
+describe('GET /api/user/home-sections', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ // Re-apply default mock implementations after clearAllMocks
+ prismaMock.userHomeSection.createMany.mockResolvedValue({ count: 0 });
+ prismaMock.userHomeSection.deleteMany.mockResolvedValue({ count: 0 });
+ prismaMock.$transaction.mockImplementation(async (fn: any) => fn(prismaMock));
+ });
+
+ it('returns default sections for new user', async () => {
+ // ensureDefaultSections check: no existing sections
+ prismaMock.userHomeSection.findMany
+ .mockResolvedValueOnce([]) // ensureDefaultSections
+ .mockResolvedValueOnce([ // actual fetch after defaults created
+ { id: '1', sectionType: 'popular', categoryId: null, categoryName: null, sortOrder: 0 },
+ { id: '2', sectionType: 'new_releases', categoryId: null, categoryName: null, sortOrder: 1 },
+ ]);
+ prismaMock.scheduledJob.findFirst.mockResolvedValueOnce(null);
+
+ const { GET } = await import('@/app/api/user/home-sections/route');
+ const request = new Request('http://localhost/api/user/home-sections');
+ const response = await GET(request as any);
+ const data = await response.json();
+
+ expect(data.success).toBe(true);
+ expect(data.sections).toHaveLength(2);
+ expect(data.sections[0].sectionType).toBe('popular');
+ expect(data.sections[1].sectionType).toBe('new_releases');
+ });
+
+ it('returns existing sections without creating defaults', async () => {
+ prismaMock.userHomeSection.findMany
+ .mockResolvedValueOnce([{ id: '1' }]) // has existing
+ .mockResolvedValueOnce([
+ { id: '1', sectionType: 'category', categoryId: '123', categoryName: 'Sci-Fi', sortOrder: 0 },
+ ]);
+ prismaMock.scheduledJob.findFirst.mockResolvedValueOnce({
+ nextRun: new Date('2026-03-05T00:00:00Z'),
+ });
+
+ const { GET } = await import('@/app/api/user/home-sections/route');
+ const request = new Request('http://localhost/api/user/home-sections');
+ const response = await GET(request as any);
+ const data = await response.json();
+
+ expect(data.success).toBe(true);
+ expect(data.sections).toHaveLength(1);
+ expect(data.sections[0].categoryName).toBe('Sci-Fi');
+ expect(data.nextRefresh).toBe('2026-03-05T00:00:00.000Z');
+ expect(prismaMock.userHomeSection.createMany).not.toHaveBeenCalled();
+ });
+});
+
+describe('PUT /api/user/home-sections', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ prismaMock.userHomeSection.createMany.mockResolvedValue({ count: 0 });
+ prismaMock.userHomeSection.deleteMany.mockResolvedValue({ count: 0 });
+ prismaMock.$transaction.mockImplementation(async (fn: any) => fn(prismaMock));
+ });
+
+ it('saves new section configuration', async () => {
+ (globalThis as any).__testBody = {
+ sections: [
+ { sectionType: 'new_releases', sortOrder: 0 },
+ { sectionType: 'popular', sortOrder: 1 },
+ { sectionType: 'category', categoryId: '123', categoryName: 'Sci-Fi', sortOrder: 2 },
+ ],
+ };
+
+ prismaMock.userHomeSection.findMany.mockResolvedValueOnce([
+ { id: '1', sectionType: 'new_releases', categoryId: null, categoryName: null, sortOrder: 0 },
+ { id: '2', sectionType: 'popular', categoryId: null, categoryName: null, sortOrder: 1 },
+ { id: '3', sectionType: 'category', categoryId: '123', categoryName: 'Sci-Fi', sortOrder: 2 },
+ ]);
+
+ const { PUT } = await import('@/app/api/user/home-sections/route');
+ const request = new Request('http://localhost/api/user/home-sections', { method: 'PUT' });
+ const response = await PUT(request as any);
+ const data = await response.json();
+
+ expect(data.success).toBe(true);
+ expect(data.sections).toHaveLength(3);
+ expect(prismaMock.userHomeSection.deleteMany).toHaveBeenCalledWith({
+ where: { userId: 'user-1' },
+ });
+ expect(prismaMock.userHomeSection.createMany).toHaveBeenCalled();
+ });
+
+ it('rejects more than 10 sections', async () => {
+ (globalThis as any).__testBody = {
+ sections: Array.from({ length: 11 }, (_, i) => ({
+ sectionType: 'category',
+ categoryId: `cat-${i}`,
+ categoryName: `Cat ${i}`,
+ sortOrder: i,
+ })),
+ };
+
+ const { PUT } = await import('@/app/api/user/home-sections/route');
+ const request = new Request('http://localhost/api/user/home-sections', { method: 'PUT' });
+ const response = await PUT(request as any);
+
+ expect(response.status).toBe(400);
+ });
+
+ it('rejects duplicate sections', async () => {
+ (globalThis as any).__testBody = {
+ sections: [
+ { sectionType: 'popular', sortOrder: 0 },
+ { sectionType: 'popular', sortOrder: 1 },
+ ],
+ };
+
+ const { PUT } = await import('@/app/api/user/home-sections/route');
+ const request = new Request('http://localhost/api/user/home-sections', { method: 'PUT' });
+ const response = await PUT(request as any);
+
+ expect(response.status).toBe(400);
+ const data = await response.json();
+ expect(data.message).toContain('Duplicate');
+ });
+
+ it('rejects category section without categoryId', async () => {
+ (globalThis as any).__testBody = {
+ sections: [{ sectionType: 'category', sortOrder: 0 }],
+ };
+
+ const { PUT } = await import('@/app/api/user/home-sections/route');
+ const request = new Request('http://localhost/api/user/home-sections', { method: 'PUT' });
+ const response = await PUT(request as any);
+
+ expect(response.status).toBe(400);
+ const data = await response.json();
+ expect(data.message).toContain('categoryId');
+ });
+});
diff --git a/tests/app/home.page.test.tsx b/tests/app/home.page.test.tsx
index 6a009e4..2bfbc72 100644
--- a/tests/app/home.page.test.tsx
+++ b/tests/app/home.page.test.tsx
@@ -1,6 +1,6 @@
/**
* Component: Home Page Tests
- * Documentation: documentation/frontend/components.md
+ * Documentation: documentation/features/home-sections.md
*/
// @vitest-environment jsdom
@@ -12,15 +12,26 @@ import { resetMockAuthState } from '../helpers/mock-auth';
import { resetMockRouter } from '../helpers/mock-next-navigation';
const useAudiobooksMock = vi.hoisted(() => vi.fn());
+const useCategoryAudiobooksMock = vi.hoisted(() => vi.fn());
+const useHomeSectionsMock = vi.hoisted(() => vi.fn());
const usePreferencesMock = vi.hoisted(() => ({
cardSize: 5,
setCardSize: vi.fn(),
+ squareCovers: false,
+ setSquareCovers: vi.fn(),
+ hideAvailable: false,
+ setHideAvailable: vi.fn(),
}));
vi.mock('@/lib/hooks/useAudiobooks', () => ({
useAudiobooks: useAudiobooksMock,
}));
+vi.mock('@/lib/hooks/useHomeSections', () => ({
+ useHomeSections: useHomeSectionsMock,
+ useCategoryAudiobooks: useCategoryAudiobooksMock,
+}));
+
vi.mock('@/contexts/PreferencesContext', () => ({
usePreferences: () => usePreferencesMock,
}));
@@ -71,9 +82,25 @@ describe('HomePage', () => {
resetMockAuthState();
resetMockRouter();
useAudiobooksMock.mockReset();
+ useCategoryAudiobooksMock.mockReset();
+ useHomeSectionsMock.mockReset();
usePreferencesMock.cardSize = 5;
usePreferencesMock.setCardSize.mockReset();
+ usePreferencesMock.hideAvailable = false;
vi.resetModules();
+
+ // Default: return popular + new_releases sections
+ useHomeSectionsMock.mockReturnValue({
+ sections: [
+ { id: '1', sectionType: 'popular', categoryId: null, categoryName: null, sortOrder: 0 },
+ { id: '2', sectionType: 'new_releases', categoryId: null, categoryName: null, sortOrder: 1 },
+ ],
+ isLoading: false,
+ nextRefresh: null,
+ saveSections: vi.fn(),
+ mutate: vi.fn(),
+ error: null,
+ });
});
it('renders empty state messaging for popular audiobooks', async () => {
@@ -97,28 +124,39 @@ describe('HomePage', () => {
const { default: HomePage } = await import('@/app/page');
render(;
findUnique: ReturnType;
create: ReturnType;
+ createMany: ReturnType;
update: ReturnType;
updateMany: ReturnType;
upsert: ReturnType;
@@ -23,6 +24,7 @@ const createModelMock = (): PrismaModelMock => ({
findFirst: vi.fn(),
findUnique: vi.fn(),
create: vi.fn(() => Promise.resolve({})),
+ createMany: vi.fn(() => Promise.resolve({ count: 0 })),
update: vi.fn(() => Promise.resolve({})),
updateMany: vi.fn(() => Promise.resolve({})),
upsert: vi.fn(() => Promise.resolve({})),
@@ -52,6 +54,9 @@ export const createPrismaMock = () => ({
workAsin: createModelMock(),
watchedSeries: createModelMock(),
watchedAuthor: createModelMock(),
+ userHomeSection: createModelMock(),
+ audibleCacheCategory: createModelMock(),
$queryRaw: vi.fn(),
+ $transaction: vi.fn(),
$disconnect: vi.fn(),
});
diff --git a/tests/processors/audible-refresh.processor.test.ts b/tests/processors/audible-refresh.processor.test.ts
index 3deb01b..bdfd7b3 100644
--- a/tests/processors/audible-refresh.processor.test.ts
+++ b/tests/processors/audible-refresh.processor.test.ts
@@ -10,6 +10,7 @@ const prismaMock = createPrismaMock();
const audibleServiceMock = vi.hoisted(() => ({
getPopularAudiobooks: vi.fn(),
getNewReleases: vi.fn(),
+ getCategoryBooks: vi.fn(),
}));
const thumbnailCacheMock = vi.hoisted(() => ({
cacheThumbnail: vi.fn(),
@@ -45,7 +46,7 @@ describe('processAudibleRefresh', () => {
global.setTimeout = origSetTimeout;
});
- it('refreshes popular and new releases, caching thumbnails', async () => {
+ it('refreshes popular and new releases via AudibleCacheCategory', async () => {
const popular = [
{
asin: 'ASIN-1',
@@ -91,8 +92,12 @@ describe('processAudibleRefresh', () => {
audibleServiceMock.getNewReleases.mockResolvedValue(newReleases);
thumbnailCacheMock.cacheThumbnail.mockResolvedValue('cached/path.jpg');
thumbnailCacheMock.cleanupUnusedThumbnails.mockResolvedValue(2);
- prismaMock.audibleCache.updateMany.mockResolvedValue({ count: 1 });
prismaMock.audibleCache.upsert.mockResolvedValue({});
+ prismaMock.audibleCacheCategory.deleteMany.mockResolvedValue({ count: 0 });
+ prismaMock.audibleCacheCategory.create.mockResolvedValue({});
+ // No user-configured categories
+ prismaMock.userHomeSection.findMany.mockResolvedValue([]);
+
prismaMock.audibleCache.findMany.mockResolvedValue([
{ asin: 'ASIN-1' },
{ asin: 'ASIN-2' },
@@ -105,8 +110,32 @@ describe('processAudibleRefresh', () => {
expect(result.success).toBe(true);
expect(result.popularSaved).toBe(2);
expect(result.newReleasesSaved).toBe(1);
- expect(prismaMock.audibleCache.updateMany).toHaveBeenCalled();
+ expect(result.categoriesSynced).toBe(0);
+
+ // Should wipe old entries for __popular__ and __new_releases__
+ expect(prismaMock.audibleCacheCategory.deleteMany).toHaveBeenCalledWith({
+ where: { categoryId: '__popular__' },
+ });
+ expect(prismaMock.audibleCacheCategory.deleteMany).toHaveBeenCalledWith({
+ where: { categoryId: '__new_releases__' },
+ });
+
+ // 3 metadata upserts (2 popular + 1 new release)
expect(prismaMock.audibleCache.upsert).toHaveBeenCalledTimes(3);
+
+ // 3 category entries created (2 popular + 1 new release)
+ expect(prismaMock.audibleCacheCategory.create).toHaveBeenCalledTimes(3);
+ expect(prismaMock.audibleCacheCategory.create).toHaveBeenCalledWith({
+ data: expect.objectContaining({ asin: 'ASIN-1', categoryId: '__popular__', rank: 1 }),
+ });
+ expect(prismaMock.audibleCacheCategory.create).toHaveBeenCalledWith({
+ data: expect.objectContaining({ asin: 'ASIN-2', categoryId: '__popular__', rank: 2 }),
+ });
+ expect(prismaMock.audibleCacheCategory.create).toHaveBeenCalledWith({
+ data: expect.objectContaining({ asin: 'ASIN-3', categoryId: '__new_releases__', rank: 1 }),
+ });
+
+ // Thumbnail caching still works
expect(thumbnailCacheMock.cacheThumbnail).toHaveBeenCalledWith('ASIN-1', 'http://image/1');
expect(thumbnailCacheMock.cacheThumbnail).toHaveBeenCalledWith('ASIN-3', 'http://image/3');
expect(thumbnailCacheMock.cleanupUnusedThumbnails).toHaveBeenCalled();
@@ -115,8 +144,56 @@ describe('processAudibleRefresh', () => {
expect(Array.from(activeSet).sort()).toEqual(['ASIN-1', 'ASIN-2', 'ASIN-3']);
});
+ it('scrapes user-configured categories after popular/new-releases', async () => {
+ audibleServiceMock.getPopularAudiobooks.mockResolvedValue([]);
+ audibleServiceMock.getNewReleases.mockResolvedValue([]);
+ thumbnailCacheMock.cacheThumbnail.mockResolvedValue('cached/cat.jpg');
+ thumbnailCacheMock.cleanupUnusedThumbnails.mockResolvedValue(0);
+ prismaMock.audibleCacheCategory.deleteMany.mockResolvedValue({ count: 0 });
+ prismaMock.audibleCacheCategory.create.mockResolvedValue({});
+
+ // User has one category section
+ prismaMock.userHomeSection.findMany.mockResolvedValue([
+ { categoryId: 'node-42' },
+ ]);
+
+ // getCategoryBooks returns 2 books
+ audibleServiceMock.getCategoryBooks.mockResolvedValue([
+ { asin: 'CAT-1', title: 'Cat Book 1', author: 'Author', coverArtUrl: 'http://img/c1' },
+ { asin: 'CAT-2', title: 'Cat Book 2', author: 'Author', coverArtUrl: null },
+ ]);
+
+ prismaMock.audibleCache.upsert.mockResolvedValue({});
+ prismaMock.audibleCache.findMany.mockResolvedValue([]);
+
+ const { processAudibleRefresh } = await import('@/lib/processors/audible-refresh.processor');
+ const result = await processAudibleRefresh({ jobId: 'job-cat' });
+
+ expect(result.categoriesSynced).toBe(1);
+ expect(audibleServiceMock.getCategoryBooks).toHaveBeenCalledWith('node-42', 200);
+
+ // Should wipe entries for __popular__, __new_releases__, and node-42
+ expect(prismaMock.audibleCacheCategory.deleteMany).toHaveBeenCalledWith({
+ where: { categoryId: '__popular__' },
+ });
+ expect(prismaMock.audibleCacheCategory.deleteMany).toHaveBeenCalledWith({
+ where: { categoryId: '__new_releases__' },
+ });
+ expect(prismaMock.audibleCacheCategory.deleteMany).toHaveBeenCalledWith({
+ where: { categoryId: 'node-42' },
+ });
+
+ // 2 category book creates (for node-42) — popular/new-releases had 0 books
+ expect(prismaMock.audibleCacheCategory.create).toHaveBeenCalledTimes(2);
+ expect(prismaMock.audibleCache.upsert).toHaveBeenCalledTimes(2);
+ });
+
it('rethrows fatal errors', async () => {
- prismaMock.audibleCache.updateMany.mockRejectedValue(new Error('DB down'));
+ // Mock audible service to return data so we reach the DB calls
+ audibleServiceMock.getPopularAudiobooks.mockResolvedValue([]);
+ audibleServiceMock.getNewReleases.mockResolvedValue([]);
+ // First DB call is now audibleCacheCategory.deleteMany (for __popular__)
+ prismaMock.audibleCacheCategory.deleteMany.mockRejectedValue(new Error('DB down'));
const { processAudibleRefresh } = await import('@/lib/processors/audible-refresh.processor');
await expect(processAudibleRefresh({ jobId: 'job-2' })).rejects.toThrow('DB down');