julienfroidefond/stripstream
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: remove caching-related API endpoints and configurations, update preferences structure, and clean up unused services
All checks were successful
Deploy with Docker Compose / deploy (push) Successful in 7m22s
Details

Browse Source
This commit is contained in:
Julien Froidefond
2026-01-03 18:55:12 +01:00
parent acd26ea427
commit 512e9a480f
49 changed files with 244 additions and 4073 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/app/api/komga/books/[bookId]/read-progress/route.ts
View File

@@ -1,7 +1,6 @@
import type { NextRequest } from "next/server";
import { NextResponse } from "next/server";
import { BookService } from "@/lib/services/book.service";
import { SeriesService } from "@/lib/services/series.service";
import { ERROR_CODES } from "@/constants/errorCodes";
import { getErrorMessage } from "@/utils/errors";
import { AppError } from "@/utils/errors";
@@ -30,16 +29,6 @@ export async function PATCH(
await BookService.updateReadProgress(bookId, page, completed);
// Invalider le cache de la série après avoir mis à jour la progression
try {
const seriesId = await BookService.getBookSeriesId(bookId);
await SeriesService.invalidateSeriesBooksCache(seriesId);
await SeriesService.invalidateSeriesCache(seriesId);
} catch (cacheError) {
// Ne pas faire échouer la requête si l'invalidation du cache échoue
logger.error({ err: cacheError }, "Erreur lors de l'invalidation du cache de la série:");
}
return NextResponse.json({ message: "📖 Progression mise à jour avec succès" });
} catch (error) {
logger.error({ err: error }, "Erreur lors de la mise à jour de la progression:");
@@ -77,16 +66,6 @@ export async function DELETE(
await BookService.deleteReadProgress(bookId);
// Invalider le cache de la série après avoir supprimé la progression
try {
const seriesId = await BookService.getBookSeriesId(bookId);
await SeriesService.invalidateSeriesBooksCache(seriesId);
await SeriesService.invalidateSeriesCache(seriesId);
} catch (cacheError) {
// Ne pas faire échouer la requête si l'invalidation du cache échoue
logger.error({ err: cacheError }, "Erreur lors de l'invalidation du cache de la série:");
}
return NextResponse.json({ message: "🗑️ Progression supprimée avec succès" });
} catch (error) {
logger.error({ err: error }, "Erreur lors de la suppression de la progression:");

46
src/app/api/komga/cache/clear/[libraryId]/[seriesId]/route.ts vendored
View File

@@ -1,46 +0,0 @@
import { NextResponse } from "next/server";
import { ERROR_CODES } from "@/constants/errorCodes";
import { getErrorMessage } from "@/utils/errors";
import { LibraryService } from "@/lib/services/library.service";
import { HomeService } from "@/lib/services/home.service";
import { SeriesService } from "@/lib/services/series.service";
import { revalidatePath } from "next/cache";
import type { NextRequest } from "next/server";
import logger from "@/lib/logger";
export async function POST(
request: NextRequest,
{ params }: { params: Promise<{ libraryId: string; seriesId: string }> }
) {
try {
const { libraryId, seriesId } = await params;
await HomeService.invalidateHomeCache();
revalidatePath("/");
if (libraryId) {
await LibraryService.invalidateLibrarySeriesCache(libraryId);
revalidatePath(`/library/${libraryId}`);
}
if (seriesId) {
await SeriesService.invalidateSeriesBooksCache(seriesId);
await SeriesService.invalidateSeriesCache(seriesId);
revalidatePath(`/series/${seriesId}`);
}
return NextResponse.json({ message: "🧹 Cache vidé avec succès" });
} catch (error) {
logger.error({ err: error }, "Erreur lors de la suppression du cache:");
return NextResponse.json(
{
error: {
code: ERROR_CODES.CACHE.CLEAR_ERROR,
name: "Cache clear error",
message: getErrorMessage(ERROR_CODES.CACHE.CLEAR_ERROR),
},
},
{ status: 500 }
);
}
}

34
src/app/api/komga/cache/clear/route.ts vendored
View File

@@ -1,34 +0,0 @@
import { NextResponse } from "next/server";
import type { ServerCacheService } from "@/lib/services/server-cache.service";
import { getServerCacheService } from "@/lib/services/server-cache.service";
import { ERROR_CODES } from "@/constants/errorCodes";
import { getErrorMessage } from "@/utils/errors";
import { revalidatePath } from "next/cache";
import logger from "@/lib/logger";
export async function POST() {
try {
const cacheService: ServerCacheService = await getServerCacheService();
await cacheService.clear();
// Revalider toutes les pages importantes après le vidage du cache
revalidatePath("/");
revalidatePath("/libraries");
revalidatePath("/series");
revalidatePath("/books");
return NextResponse.json({ message: "🧹 Cache vidé avec succès" });
} catch (error) {
logger.error({ err: error }, "Erreur lors de la suppression du cache:");
return NextResponse.json(
{
error: {
code: ERROR_CODES.CACHE.CLEAR_ERROR,
name: "Cache clear error",
message: getErrorMessage(ERROR_CODES.CACHE.CLEAR_ERROR),
},
},
{ status: 500 }
);
}
}

27
src/app/api/komga/cache/entries/route.ts vendored
View File

@@ -1,27 +0,0 @@
import { NextResponse } from "next/server";
import type { ServerCacheService } from "@/lib/services/server-cache.service";
import { getServerCacheService } from "@/lib/services/server-cache.service";
import { ERROR_CODES } from "@/constants/errorCodes";
import { getErrorMessage } from "@/utils/errors";
import logger from "@/lib/logger";
export async function GET() {
try {
const cacheService: ServerCacheService = await getServerCacheService();
const entries = await cacheService.getCacheEntries();
return NextResponse.json({ entries });
} catch (error) {
logger.error({ err: error }, "Erreur lors de la récupération des entrées du cache");
return NextResponse.json(
{
error: {
code: ERROR_CODES.CACHE.SIZE_FETCH_ERROR,
name: "Cache entries fetch error",
message: getErrorMessage(ERROR_CODES.CACHE.SIZE_FETCH_ERROR),
},
},
{ status: 500 }
);
}
}

60
src/app/api/komga/cache/mode/route.ts vendored
View File

@@ -1,60 +0,0 @@
import { NextResponse } from "next/server";
import type { CacheMode, ServerCacheService } from "@/lib/services/server-cache.service";
import { getServerCacheService } from "@/lib/services/server-cache.service";
import { ERROR_CODES } from "@/constants/errorCodes";
import { getErrorMessage } from "@/utils/errors";
import type { NextRequest } from "next/server";
import logger from "@/lib/logger";
export async function GET() {
try {
const cacheService: ServerCacheService = await getServerCacheService();
return NextResponse.json({ mode: cacheService.getCacheMode() });
} catch (error) {
logger.error({ err: error }, "Erreur lors de la récupération du mode de cache:");
return NextResponse.json(
{
error: {
code: ERROR_CODES.CACHE.MODE_FETCH_ERROR,
name: "Cache mode fetch error",
message: getErrorMessage(ERROR_CODES.CACHE.MODE_FETCH_ERROR),
},
},
{ status: 500 }
);
}
}
export async function POST(request: NextRequest) {
try {
const { mode }: { mode: CacheMode } = await request.json();
if (mode !== "file" && mode !== "memory") {
return NextResponse.json(
{
error: {
code: ERROR_CODES.CACHE.INVALID_MODE,
name: "Invalid cache mode",
message: getErrorMessage(ERROR_CODES.CACHE.INVALID_MODE),
},
},
{ status: 400 }
);
}
const cacheService: ServerCacheService = await getServerCacheService();
cacheService.setCacheMode(mode);
return NextResponse.json({ mode: cacheService.getCacheMode() });
} catch (error) {
logger.error({ err: error }, "Erreur lors de la mise à jour du mode de cache:");
return NextResponse.json(
{
error: {
code: ERROR_CODES.CACHE.MODE_UPDATE_ERROR,
name: "Cache mode update error",
message: getErrorMessage(ERROR_CODES.CACHE.MODE_UPDATE_ERROR),
},
},
{ status: 500 }
);
}
}

31
src/app/api/komga/cache/size/route.ts vendored
View File

@@ -1,31 +0,0 @@
import { NextResponse } from "next/server";
import type { ServerCacheService } from "@/lib/services/server-cache.service";
import { getServerCacheService } from "@/lib/services/server-cache.service";
import { ERROR_CODES } from "@/constants/errorCodes";
import { getErrorMessage } from "@/utils/errors";
import logger from "@/lib/logger";
export async function GET() {
try {
const cacheService: ServerCacheService = await getServerCacheService();
const { sizeInBytes, itemCount } = await cacheService.getCacheSize();
return NextResponse.json({
sizeInBytes,
itemCount,
mode: cacheService.getCacheMode(),
});
} catch (error) {
logger.error({ err: error }, "Erreur lors de la récupération de la taille du cache:");
return NextResponse.json(
{
error: {
code: ERROR_CODES.CACHE.SIZE_FETCH_ERROR,
name: "Cache size fetch error",
message: getErrorMessage(ERROR_CODES.CACHE.SIZE_FETCH_ERROR),
},
},
{ status: 500 }
);
}
}

31
src/app/api/komga/home/route.ts
View File

@@ -35,34 +35,3 @@ export async function GET() {
);
}
}
export async function DELETE() {
try {
await HomeService.invalidateHomeCache();
return NextResponse.json({ success: true });
} catch (error) {
logger.error({ err: error }, "API Home - Erreur lors de l'invalidation du cache:");
if (error instanceof AppError) {
return NextResponse.json(
{
error: {
code: error.code,
name: "Cache invalidation error",
message: getErrorMessage(error.code),
},
},
{ status: 500 }
);
}
return NextResponse.json(
{
error: {
code: ERROR_CODES.CACHE.DELETE_ERROR,
name: "Cache invalidation error",
message: getErrorMessage(ERROR_CODES.CACHE.DELETE_ERROR),
},
},
{ status: 500 }
);
}
}

37
src/app/api/komga/libraries/[libraryId]/series/route.ts
View File

@@ -53,40 +53,3 @@ export async function GET(
);
}
}
export async function DELETE(
request: NextRequest,
{ params }: { params: Promise<{ libraryId: string }> }
) {
try {
const libraryId: string = (await params).libraryId;
await LibraryService.invalidateLibrarySeriesCache(libraryId);
return NextResponse.json({ success: true });
} catch (error) {
logger.error({ err: error }, "API Library Cache Invalidation - Erreur:");
if (error instanceof AppError) {
return NextResponse.json(
{
error: {
code: error.code,
name: "Cache invalidation error",
message: getErrorMessage(error.code),
},
},
{ status: 500 }
);
}
return NextResponse.json(
{
error: {
code: ERROR_CODES.CACHE.DELETE_ERROR,
name: "Cache invalidation error",
message: getErrorMessage(ERROR_CODES.CACHE.DELETE_ERROR),
},
},
{ status: 500 }
);
}
}

40
src/app/api/komga/series/[seriesId]/books/route.ts
View File

@@ -52,43 +52,3 @@ export async function GET(
);
}
}
export async function DELETE(
request: NextRequest,
{ params }: { params: Promise<{ seriesId: string }> }
) {
try {
const seriesId: string = (await params).seriesId;
await Promise.all([
SeriesService.invalidateSeriesBooksCache(seriesId),
SeriesService.invalidateSeriesCache(seriesId),
]);
return NextResponse.json({ success: true });
} catch (error) {
logger.error({ err: error }, "API Series Cache Invalidation - Erreur:");
if (error instanceof AppError) {
return NextResponse.json(
{
error: {
code: error.code,
name: "Cache invalidation error",
message: getErrorMessage(error.code),
},
},
{ status: 500 }
);
}
return NextResponse.json(
{
error: {
code: ERROR_CODES.CACHE.DELETE_ERROR,
name: "Cache invalidation error",
message: getErrorMessage(ERROR_CODES.CACHE.DELETE_ERROR),
},
},
{ status: 500 }
);
}
}

87
src/app/api/komga/ttl-config/route.ts
View File

@@ -1,87 +0,0 @@
import { NextResponse } from "next/server";
import { ConfigDBService } from "@/lib/services/config-db.service";
import { ERROR_CODES } from "@/constants/errorCodes";
import type { TTLConfig } from "@/types/komga";
import { getErrorMessage } from "@/utils/errors";
import type { NextRequest } from "next/server";
import logger from "@/lib/logger";
export async function GET() {
try {
const config: TTLConfig | null = await ConfigDBService.getTTLConfig();
return NextResponse.json(config);
} catch (error) {
logger.error({ err: error }, "Erreur lors de la récupération de la configuration TTL");
if (error instanceof Error) {
if (error.message === getErrorMessage(ERROR_CODES.MIDDLEWARE.UNAUTHORIZED)) {
return NextResponse.json(
{
error: {
name: "Unauthorized",
code: ERROR_CODES.MIDDLEWARE.UNAUTHORIZED,
message: getErrorMessage(ERROR_CODES.MIDDLEWARE.UNAUTHORIZED),
},
},
{ status: 401 }
);
}
}
return NextResponse.json(
{
error: {
name: "TTL fetch error",
code: ERROR_CODES.CONFIG.TTL_FETCH_ERROR,
message: getErrorMessage(ERROR_CODES.CONFIG.TTL_FETCH_ERROR),
},
},
{ status: 500 }
);
}
}
export async function POST(request: NextRequest) {
try {
const data = await request.json();
const config: TTLConfig = await ConfigDBService.saveTTLConfig(data);
return NextResponse.json({
message: "⏱️ Configuration TTL sauvegardée avec succès",
config: {
defaultTTL: config.defaultTTL,
homeTTL: config.homeTTL,
librariesTTL: config.librariesTTL,
seriesTTL: config.seriesTTL,
booksTTL: config.booksTTL,
imagesTTL: config.imagesTTL,
imageCacheMaxAge: config.imageCacheMaxAge,
},
});
} catch (error) {
logger.error({ err: error }, "Erreur lors de la sauvegarde de la configuration TTL");
if (
error instanceof Error &&
error.message === getErrorMessage(ERROR_CODES.MIDDLEWARE.UNAUTHORIZED)
) {
return NextResponse.json(
{
error: {
name: "Unauthorized",
code: ERROR_CODES.MIDDLEWARE.UNAUTHORIZED,
message: getErrorMessage(ERROR_CODES.MIDDLEWARE.UNAUTHORIZED),
},
},
{ status: 401 }
);
}
return NextResponse.json(
{
error: {
name: "TTL save error",
code: ERROR_CODES.CONFIG.TTL_SAVE_ERROR,
message: getErrorMessage(ERROR_CODES.CONFIG.TTL_SAVE_ERROR),
},
},
{ status: 500 }
);
}
}