feat: add multi-provider support (Komga + Stripstream Librarian)

- Introduce provider abstraction layer (IMediaProvider, KomgaProvider, StripstreamProvider)
- Add Stripstream Librarian as second media provider with full feature parity
- Migrate all pages and components from direct Komga services to provider factory
- Remove dead service code (BaseApiService, HomeService, LibraryService, SearchService, TestService)
- Fix library/series page-based pagination for both providers (Komga 0-indexed, Stripstream 1-indexed)
- Fix unread filter and search on library page for both providers
- Fix read progress display for Stripstream (reading_status mapping)
- Fix series read status (books_read_count) for Stripstream
- Add global search with series results for Stripstream (series_hits from Meilisearch)
- Fix thumbnail proxy to return 404 gracefully instead of JSON on upstream error
- Replace duration-based cache debug detection with x-nextjs-cache header

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

src/app/api/komga/search/route.ts

@@ -1,72 +0,0 @@
-import type { NextRequest } from "next/server";
-import { NextResponse } from "next/server";
-import { SearchService } from "@/lib/services/search.service";
-import { AppError, getErrorMessage } from "@/utils/errors";
-import { ERROR_CODES } from "@/constants/errorCodes";
-
-const MIN_QUERY_LENGTH = 2;
-const DEFAULT_LIMIT = 6;
-const MAX_LIMIT = 10;
-
-export async function GET(request: NextRequest) {
-  try {
-    const query = request.nextUrl.searchParams.get("q")?.trim() ?? "";
-    const limitParam = request.nextUrl.searchParams.get("limit");
-    const parsedLimit = limitParam ? Number(limitParam) : Number.NaN;
-    const limit = Number.isFinite(parsedLimit)
-      ? Math.max(1, Math.min(parsedLimit, MAX_LIMIT))
-      : DEFAULT_LIMIT;
-
-    if (query.length < MIN_QUERY_LENGTH) {
-      return NextResponse.json({ series: [], books: [] }, { headers: { "Cache-Control": "no-store" } });
-    }
-
-    const results = await SearchService.globalSearch(query, limit);
-
-    return NextResponse.json(
-      {
-        series: results.series.map((series) => ({
-          id: series.id,
-          title: series.metadata.title,
-          libraryId: series.libraryId,
-          booksCount: series.booksCount,
-          href: `/series/${series.id}`,
-          coverUrl: `/api/komga/images/series/${series.id}/thumbnail`,
-        })),
-        books: results.books.map((book) => ({
-          id: book.id,
-          title: book.metadata.title || book.name,
-          seriesTitle: book.seriesTitle,
-          seriesId: book.seriesId,
-          href: `/books/${book.id}`,
-          coverUrl: `/api/komga/images/books/${book.id}/thumbnail`,
-        })),
-      },
-      { headers: { "Cache-Control": "no-store" } }
-    );
-  } catch (error) {
-    if (error instanceof AppError) {
-      return NextResponse.json(
-        {
-          error: {
-            code: error.code,
-            name: "Search fetch error",
-            message: getErrorMessage(error.code),
-          },
-        },
-        { status: 500 }
-      );
-    }
-
-    return NextResponse.json(
-      {
-        error: {
-          code: ERROR_CODES.SERIES.FETCH_ERROR,
-          name: "Search fetch error",
-          message: getErrorMessage(ERROR_CODES.SERIES.FETCH_ERROR),
-        },
-      },
-      { status: 500 }
-    );
-  }
-}

src/app/api/provider/search/route.ts

@@ -0,0 +1,44 @@
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import { getProvider } from "@/lib/providers/provider.factory";
+import { AppError, getErrorMessage } from "@/utils/errors";
+import { ERROR_CODES } from "@/constants/errorCodes";
+
+const MIN_QUERY_LENGTH = 2;
+const DEFAULT_LIMIT = 6;
+const MAX_LIMIT = 10;
+
+export async function GET(request: NextRequest) {
+  try {
+    const query = request.nextUrl.searchParams.get("q")?.trim() ?? "";
+    const limitParam = request.nextUrl.searchParams.get("limit");
+    const parsedLimit = limitParam ? Number(limitParam) : Number.NaN;
+    const limit = Number.isFinite(parsedLimit)
+      ? Math.max(1, Math.min(parsedLimit, MAX_LIMIT))
+      : DEFAULT_LIMIT;
+
+    if (query.length < MIN_QUERY_LENGTH) {
+      return NextResponse.json([], { headers: { "Cache-Control": "no-store" } });
+    }
+
+    const provider = await getProvider();
+    if (!provider) {
+      return NextResponse.json([], { headers: { "Cache-Control": "no-store" } });
+    }
+
+    const results = await provider.search(query, limit);
+
+    return NextResponse.json(results, { headers: { "Cache-Control": "no-store" } });
+  } catch (error) {
+    if (error instanceof AppError) {
+      return NextResponse.json(
+        { error: { code: error.code, message: getErrorMessage(error.code) } },
+        { status: 500 }
+      );
+    }
+    return NextResponse.json(
+      { error: { code: ERROR_CODES.CLIENT.FETCH_ERROR, message: "Search error" } },
+      { status: 500 }
+    );
+  }
+}

src/app/api/stripstream/images/books/[bookId]/pages/[pageNumber]/route.ts

@@ -0,0 +1,60 @@
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth-utils";
+import prisma from "@/lib/prisma";
+import { StripstreamClient } from "@/lib/providers/stripstream/stripstream.client";
+import { ERROR_CODES } from "@/constants/errorCodes";
+import { AppError } from "@/utils/errors";
+import { getErrorMessage } from "@/utils/errors";
+import logger from "@/lib/logger";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ bookId: string; pageNumber: string }> }
+) {
+  try {
+    const { bookId, pageNumber } = await params;
+
+    const user = await getCurrentUser();
+    if (!user) {
+      return NextResponse.json({ error: { code: "AUTH_UNAUTHENTICATED" } }, { status: 401 });
+    }
+
+    const userId = parseInt(user.id, 10);
+    const config = await prisma.stripstreamConfig.findUnique({ where: { userId } });
+    if (!config) {
+      throw new AppError(ERROR_CODES.STRIPSTREAM.MISSING_CONFIG);
+    }
+
+    const queryString = request.nextUrl.search.slice(1); // strip leading '?'
+    const path = `books/${bookId}/pages/${pageNumber}${queryString ? `?${queryString}` : ""}`;
+
+    const client = new StripstreamClient(config.url, config.token);
+    const response = await client.fetchImage(path);
+
+    const contentType = response.headers.get("content-type") ?? "image/jpeg";
+    const buffer = await response.arrayBuffer();
+
+    return new NextResponse(buffer, {
+      headers: {
+        "Content-Type": contentType,
+        "Cache-Control": "public, max-age=86400",
+      },
+    });
+  } catch (error) {
+    logger.error({ err: error }, "Stripstream page fetch error");
+
+    if (error instanceof AppError) {
+      return NextResponse.json(
+        { error: { code: error.code, message: getErrorMessage(error.code) } },
+        { status: 500 }
+      );
+    }
+    return NextResponse.json(
+      { error: { code: ERROR_CODES.IMAGE.FETCH_ERROR, message: "Image fetch error" } },
+      { status: 500 }
+    );
+  }
+}

src/app/api/stripstream/images/books/[bookId]/thumbnail/route.ts

@@ -0,0 +1,44 @@
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth-utils";
+import prisma from "@/lib/prisma";
+import { StripstreamClient } from "@/lib/providers/stripstream/stripstream.client";
+import { AppError } from "@/utils/errors";
+import { ERROR_CODES } from "@/constants/errorCodes";
+import logger from "@/lib/logger";
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ bookId: string }> }
+) {
+  try {
+    const { bookId } = await params;
+
+    const user = await getCurrentUser();
+    if (!user) {
+      return NextResponse.json({ error: { code: "AUTH_UNAUTHENTICATED" } }, { status: 401 });
+    }
+
+    const userId = parseInt(user.id, 10);
+    const config = await prisma.stripstreamConfig.findUnique({ where: { userId } });
+    if (!config) {
+      throw new AppError(ERROR_CODES.STRIPSTREAM.MISSING_CONFIG);
+    }
+
+    const client = new StripstreamClient(config.url, config.token);
+    const response = await client.fetchImage(`books/${bookId}/thumbnail`);
+
+    const contentType = response.headers.get("content-type") ?? "image/jpeg";
+    const buffer = await response.arrayBuffer();
+
+    return new NextResponse(buffer, {
+      headers: {
+        "Content-Type": contentType,
+        "Cache-Control": "public, max-age=2592000, immutable",
+      },
+    });
+  } catch (error) {
+    logger.error({ err: error }, "Stripstream thumbnail fetch error");
+    return new NextResponse(null, { status: 404 });
+  }
+}

src/app/api/stripstream/search/route.ts

@@ -0,0 +1,44 @@
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import { getProvider } from "@/lib/providers/provider.factory";
+import { AppError, getErrorMessage } from "@/utils/errors";
+import { ERROR_CODES } from "@/constants/errorCodes";
+
+const MIN_QUERY_LENGTH = 2;
+const DEFAULT_LIMIT = 6;
+const MAX_LIMIT = 10;
+
+export async function GET(request: NextRequest) {
+  try {
+    const query = request.nextUrl.searchParams.get("q")?.trim() ?? "";
+    const limitParam = request.nextUrl.searchParams.get("limit");
+    const parsedLimit = limitParam ? Number(limitParam) : Number.NaN;
+    const limit = Number.isFinite(parsedLimit)
+      ? Math.max(1, Math.min(parsedLimit, MAX_LIMIT))
+      : DEFAULT_LIMIT;
+
+    if (query.length < MIN_QUERY_LENGTH) {
+      return NextResponse.json([], { headers: { "Cache-Control": "no-store" } });
+    }
+
+    const provider = await getProvider();
+    if (!provider) {
+      throw new AppError(ERROR_CODES.STRIPSTREAM.MISSING_CONFIG);
+    }
+
+    const results = await provider.search(query, limit);
+
+    return NextResponse.json(results, { headers: { "Cache-Control": "no-store" } });
+  } catch (error) {
+    if (error instanceof AppError) {
+      return NextResponse.json(
+        { error: { code: error.code, message: getErrorMessage(error.code) } },
+        { status: 500 }
+      );
+    }
+    return NextResponse.json(
+      { error: { code: ERROR_CODES.CLIENT.FETCH_ERROR, message: "Search error" } },
+      { status: 500 }
+    );
+  }
+}