731 lines
22 KiB
TypeScript
731 lines
22 KiB
TypeScript
import fs from "fs";
|
|
import path from "path";
|
|
import { PreferencesService } from "./preferences.service";
|
|
import { getCurrentUser } from "../auth-utils";
|
|
import logger from "@/lib/logger";
|
|
|
|
export type CacheMode = "file" | "memory";
|
|
|
|
interface CacheConfig {
|
|
mode: CacheMode;
|
|
}
|
|
|
|
class ServerCacheService {
|
|
private static instance: ServerCacheService;
|
|
private cacheDir: string;
|
|
private memoryCache: Map<string, { data: unknown; expiry: number }> = new Map();
|
|
private config: CacheConfig = {
|
|
mode: "memory",
|
|
};
|
|
|
|
// Configuration des temps de cache en millisecondes
|
|
private static readonly oneMinute = 1 * 60 * 1000;
|
|
private static readonly twoMinutes = 2 * 60 * 1000;
|
|
private static readonly fiveMinutes = 5 * 60 * 1000;
|
|
private static readonly tenMinutes = 10 * 60 * 1000;
|
|
private static readonly twentyFourHours = 24 * 60 * 60 * 1000;
|
|
private static readonly oneWeek = 7 * 24 * 60 * 60 * 1000;
|
|
private static readonly noCache = 0;
|
|
|
|
// Configuration des temps de cache
|
|
// Optimisé pour la pagination native Komga :
|
|
// - Listes paginées (SERIES, BOOKS) : TTL court (2 min) car données fraîches + progression utilisateur
|
|
// - Données agrégées (HOME) : TTL moyen (10 min) car plusieurs sources
|
|
// - Données statiques (LIBRARIES) : TTL long (24h) car changent rarement
|
|
// - Images : TTL très long (7 jours) car immuables
|
|
private static readonly DEFAULT_TTL = {
|
|
DEFAULT: ServerCacheService.fiveMinutes,
|
|
HOME: ServerCacheService.tenMinutes,
|
|
LIBRARIES: ServerCacheService.twentyFourHours,
|
|
SERIES: ServerCacheService.twoMinutes, // Listes paginées avec progression
|
|
BOOKS: ServerCacheService.twoMinutes, // Listes paginées avec progression
|
|
IMAGES: ServerCacheService.oneWeek,
|
|
};
|
|
|
|
private constructor() {
|
|
this.cacheDir = path.join(process.cwd(), ".cache");
|
|
this.ensureCacheDirectory();
|
|
this.cleanExpiredCache();
|
|
this.initializeCacheMode();
|
|
}
|
|
|
|
private async initializeCacheMode(): Promise<void> {
|
|
try {
|
|
const user = await getCurrentUser();
|
|
if (!user) {
|
|
this.setCacheMode("memory");
|
|
return;
|
|
}
|
|
const preferences = await PreferencesService.getPreferences();
|
|
this.setCacheMode(preferences.cacheMode);
|
|
} catch (error) {
|
|
logger.error({ err: error }, "Error initializing cache mode from preferences");
|
|
// Keep default memory mode if preferences can't be loaded
|
|
}
|
|
}
|
|
|
|
private ensureCacheDirectory(): void {
|
|
if (!fs.existsSync(this.cacheDir)) {
|
|
fs.mkdirSync(this.cacheDir, { recursive: true });
|
|
}
|
|
}
|
|
|
|
private getCacheFilePath(key: string): string {
|
|
// Nettoyer la clé des caractères spéciaux et des doubles slashes
|
|
const sanitizedKey = key.replace(/[<>:"|?*]/g, "_").replace(/\/+/g, "/");
|
|
|
|
const filePath = path.join(this.cacheDir, `${sanitizedKey}.json`);
|
|
|
|
return filePath;
|
|
}
|
|
|
|
private cleanExpiredCache(): void {
|
|
if (!fs.existsSync(this.cacheDir)) return;
|
|
|
|
const cleanDirectory = (dirPath: string): boolean => {
|
|
if (!fs.existsSync(dirPath)) return true;
|
|
|
|
const items = fs.readdirSync(dirPath);
|
|
let isEmpty = true;
|
|
|
|
for (const item of items) {
|
|
const itemPath = path.join(dirPath, item);
|
|
|
|
try {
|
|
const stats = fs.statSync(itemPath);
|
|
|
|
if (stats.isDirectory()) {
|
|
const isSubDirEmpty = cleanDirectory(itemPath);
|
|
if (isSubDirEmpty) {
|
|
try {
|
|
fs.rmdirSync(itemPath);
|
|
} catch (error) {
|
|
logger.error(
|
|
{ err: error, path: itemPath },
|
|
`Could not remove directory ${itemPath}`
|
|
);
|
|
isEmpty = false;
|
|
}
|
|
} else {
|
|
isEmpty = false;
|
|
}
|
|
} else if (stats.isFile() && item.endsWith(".json")) {
|
|
try {
|
|
const content = fs.readFileSync(itemPath, "utf-8");
|
|
const cached = JSON.parse(content);
|
|
if (cached.expiry < Date.now()) {
|
|
fs.unlinkSync(itemPath);
|
|
} else {
|
|
isEmpty = false;
|
|
}
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Could not parse file ${itemPath}`);
|
|
// Si le fichier est corrompu, on le supprime
|
|
try {
|
|
fs.unlinkSync(itemPath);
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Could not remove file ${itemPath}`);
|
|
isEmpty = false;
|
|
}
|
|
}
|
|
} else {
|
|
isEmpty = false;
|
|
}
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Could not access ${itemPath}`);
|
|
// En cas d'erreur sur le fichier/dossier, on continue
|
|
isEmpty = false;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return isEmpty;
|
|
};
|
|
|
|
cleanDirectory(this.cacheDir);
|
|
}
|
|
|
|
public static async getInstance(): Promise<ServerCacheService> {
|
|
if (!ServerCacheService.instance) {
|
|
ServerCacheService.instance = new ServerCacheService();
|
|
await ServerCacheService.instance.initializeCacheMode();
|
|
}
|
|
return ServerCacheService.instance;
|
|
}
|
|
|
|
/**
|
|
* Retourne le TTL pour un type de données spécifique
|
|
*/
|
|
public getTTL(type: keyof typeof ServerCacheService.DEFAULT_TTL): number {
|
|
// Utiliser directement la valeur par défaut
|
|
return ServerCacheService.DEFAULT_TTL[type];
|
|
}
|
|
|
|
public setCacheMode(mode: CacheMode): void {
|
|
if (this.config.mode === mode) return;
|
|
|
|
// Si on passe de mémoire à fichier, on sauvegarde le cache en mémoire
|
|
if (mode === "file" && this.config.mode === "memory") {
|
|
this.memoryCache.forEach((value, key) => {
|
|
if (value.expiry > Date.now()) {
|
|
this.saveToFile(key, value);
|
|
}
|
|
});
|
|
this.memoryCache.clear();
|
|
}
|
|
// Si on passe de fichier à mémoire, on charge le cache fichier en mémoire
|
|
else if (mode === "memory" && this.config.mode === "file") {
|
|
this.loadFileCacheToMemory();
|
|
}
|
|
|
|
this.config.mode = mode;
|
|
}
|
|
|
|
public getCacheMode(): CacheMode {
|
|
return this.config.mode;
|
|
}
|
|
|
|
private loadFileCacheToMemory(): void {
|
|
if (!fs.existsSync(this.cacheDir)) return;
|
|
|
|
const loadDirectory = (dirPath: string) => {
|
|
const items = fs.readdirSync(dirPath);
|
|
|
|
for (const item of items) {
|
|
const itemPath = path.join(dirPath, item);
|
|
try {
|
|
const stats = fs.statSync(itemPath);
|
|
|
|
if (stats.isDirectory()) {
|
|
loadDirectory(itemPath);
|
|
} else if (stats.isFile() && item.endsWith(".json")) {
|
|
try {
|
|
const content = fs.readFileSync(itemPath, "utf-8");
|
|
const cached = JSON.parse(content);
|
|
if (cached.expiry > Date.now()) {
|
|
const key = path.relative(this.cacheDir, itemPath).slice(0, -5); // Remove .json
|
|
this.memoryCache.set(key, cached);
|
|
}
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Could not parse file ${itemPath}`);
|
|
// Ignore les fichiers corrompus
|
|
}
|
|
}
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Could not access ${itemPath}`);
|
|
// Ignore les erreurs d'accès
|
|
}
|
|
}
|
|
};
|
|
|
|
loadDirectory(this.cacheDir);
|
|
}
|
|
|
|
private saveToFile(key: string, value: { data: unknown; expiry: number }): void {
|
|
const filePath = this.getCacheFilePath(key);
|
|
const dirPath = path.dirname(filePath);
|
|
|
|
try {
|
|
if (!fs.existsSync(dirPath)) {
|
|
fs.mkdirSync(dirPath, { recursive: true });
|
|
}
|
|
fs.writeFileSync(filePath, JSON.stringify(value), "utf-8");
|
|
} catch (error) {
|
|
logger.error({ err: error, path: filePath }, `Could not write cache file ${filePath}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Met en cache des données avec une durée de vie
|
|
*/
|
|
set(key: string, data: any, type: keyof typeof ServerCacheService.DEFAULT_TTL = "DEFAULT"): void {
|
|
const cacheData = {
|
|
data,
|
|
expiry: Date.now() + this.getTTL(type),
|
|
};
|
|
|
|
if (this.config.mode === "memory") {
|
|
this.memoryCache.set(key, cacheData);
|
|
} else {
|
|
const filePath = this.getCacheFilePath(key);
|
|
const dirPath = path.dirname(filePath);
|
|
|
|
try {
|
|
if (!fs.existsSync(dirPath)) {
|
|
fs.mkdirSync(dirPath, { recursive: true });
|
|
}
|
|
fs.writeFileSync(filePath, JSON.stringify(cacheData), "utf-8");
|
|
} catch (error) {
|
|
logger.error({ err: error, path: filePath }, `Error writing cache file ${filePath}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Récupère des données du cache si elles sont valides
|
|
*/
|
|
get(key: string): any | null {
|
|
if (this.config.mode === "memory") {
|
|
const cached = this.memoryCache.get(key);
|
|
if (!cached) return null;
|
|
|
|
if (cached.expiry > Date.now()) {
|
|
return cached.data;
|
|
}
|
|
|
|
this.memoryCache.delete(key);
|
|
return null;
|
|
}
|
|
|
|
const filePath = this.getCacheFilePath(key);
|
|
if (!fs.existsSync(filePath)) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
const content = fs.readFileSync(filePath, "utf-8");
|
|
const cached = JSON.parse(content);
|
|
|
|
if (cached.expiry > Date.now()) {
|
|
return cached.data;
|
|
}
|
|
|
|
fs.unlinkSync(filePath);
|
|
return null;
|
|
} catch (error) {
|
|
logger.error({ err: error, path: filePath }, `Error reading cache file ${filePath}`);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Récupère des données du cache même si elles sont expirées (stale)
|
|
* Retourne { data, isStale } ou null si pas de cache
|
|
*/
|
|
private getStale(key: string): { data: any; isStale: boolean } | null {
|
|
if (this.config.mode === "memory") {
|
|
const cached = this.memoryCache.get(key);
|
|
if (!cached) return null;
|
|
|
|
return {
|
|
data: cached.data,
|
|
isStale: cached.expiry <= Date.now(),
|
|
};
|
|
}
|
|
|
|
const filePath = this.getCacheFilePath(key);
|
|
if (!fs.existsSync(filePath)) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
const content = fs.readFileSync(filePath, "utf-8");
|
|
const cached = JSON.parse(content);
|
|
|
|
return {
|
|
data: cached.data,
|
|
isStale: cached.expiry <= Date.now(),
|
|
};
|
|
} catch (error) {
|
|
logger.error({ err: error, path: filePath }, `Error reading cache file ${filePath}`);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Supprime une entrée du cache
|
|
*/
|
|
async delete(key: string): Promise<void> {
|
|
const user = await getCurrentUser();
|
|
if (!user) {
|
|
throw new Error("Utilisateur non authentifié");
|
|
}
|
|
const cacheKey = `${user.id}-${key}`;
|
|
|
|
if (this.config.mode === "memory") {
|
|
this.memoryCache.delete(cacheKey);
|
|
} else {
|
|
const filePath = this.getCacheFilePath(cacheKey);
|
|
if (fs.existsSync(filePath)) {
|
|
fs.unlinkSync(filePath);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Supprime toutes les entrées du cache qui commencent par un préfixe
|
|
*/
|
|
async deleteAll(prefix: string): Promise<void> {
|
|
const user = await getCurrentUser();
|
|
if (!user) {
|
|
throw new Error("Utilisateur non authentifié");
|
|
}
|
|
const prefixKey = `${user.id}-${prefix}`;
|
|
|
|
if (this.config.mode === "memory") {
|
|
this.memoryCache.forEach((value, key) => {
|
|
if (key.startsWith(prefixKey)) {
|
|
this.memoryCache.delete(key);
|
|
}
|
|
});
|
|
} else {
|
|
// En mode fichier, parcourir récursivement tous les fichiers et supprimer ceux qui correspondent
|
|
if (!fs.existsSync(this.cacheDir)) return;
|
|
|
|
const deleteMatchingFiles = (dirPath: string): void => {
|
|
const items = fs.readdirSync(dirPath);
|
|
|
|
for (const item of items) {
|
|
const itemPath = path.join(dirPath, item);
|
|
try {
|
|
const stats = fs.statSync(itemPath);
|
|
|
|
if (stats.isDirectory()) {
|
|
deleteMatchingFiles(itemPath);
|
|
// Supprimer le répertoire s'il est vide après suppression des fichiers
|
|
try {
|
|
const remainingItems = fs.readdirSync(itemPath);
|
|
if (remainingItems.length === 0) {
|
|
fs.rmdirSync(itemPath);
|
|
}
|
|
} catch {
|
|
// Ignore les erreurs de suppression de répertoire
|
|
}
|
|
} else if (stats.isFile() && item.endsWith(".json")) {
|
|
// Extraire la clé du chemin relatif (sans l'extension .json)
|
|
const relativePath = path.relative(this.cacheDir, itemPath);
|
|
const key = relativePath.slice(0, -5).replace(/\\/g, "/"); // Remove .json and normalize slashes
|
|
|
|
if (key.startsWith(prefixKey)) {
|
|
fs.unlinkSync(itemPath);
|
|
if (process.env.CACHE_DEBUG === "true") {
|
|
logger.debug(`🗑️ [CACHE DELETE] ${key}`);
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Could not delete cache file ${itemPath}`);
|
|
}
|
|
}
|
|
};
|
|
|
|
deleteMatchingFiles(this.cacheDir);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Vide le cache
|
|
*/
|
|
clear(): void {
|
|
if (this.config.mode === "memory") {
|
|
this.memoryCache.clear();
|
|
return;
|
|
}
|
|
|
|
if (!fs.existsSync(this.cacheDir)) return;
|
|
|
|
const removeDirectory = (dirPath: string) => {
|
|
if (!fs.existsSync(dirPath)) return;
|
|
|
|
const items = fs.readdirSync(dirPath);
|
|
|
|
for (const item of items) {
|
|
const itemPath = path.join(dirPath, item);
|
|
try {
|
|
const stats = fs.statSync(itemPath);
|
|
|
|
if (stats.isDirectory()) {
|
|
removeDirectory(itemPath);
|
|
try {
|
|
fs.rmdirSync(itemPath);
|
|
} catch (error) {
|
|
logger.error(
|
|
{ err: error, path: itemPath },
|
|
`Could not remove directory ${itemPath}`
|
|
);
|
|
}
|
|
} else {
|
|
try {
|
|
fs.unlinkSync(itemPath);
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Could not remove file ${itemPath}`);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Error accessing ${itemPath}`);
|
|
}
|
|
}
|
|
};
|
|
|
|
try {
|
|
removeDirectory(this.cacheDir);
|
|
} catch (error) {
|
|
logger.error({ err: error }, "Error clearing cache");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Récupère des données du cache ou exécute la fonction si nécessaire
|
|
* Stratégie stale-while-revalidate:
|
|
* - Cache valide → retourne immédiatement
|
|
* - Cache expiré → retourne le cache expiré ET revalide en background
|
|
* - Pas de cache → fetch normalement
|
|
*/
|
|
async getOrSet<T>(
|
|
key: string,
|
|
fetcher: () => Promise<T>,
|
|
type: keyof typeof ServerCacheService.DEFAULT_TTL = "DEFAULT"
|
|
): Promise<T> {
|
|
const startTime = performance.now();
|
|
const user = await getCurrentUser();
|
|
if (!user) {
|
|
throw new Error("Utilisateur non authentifié");
|
|
}
|
|
|
|
const cacheKey = `${user.id}-${key}`;
|
|
const cachedResult = this.getStale(cacheKey);
|
|
|
|
if (cachedResult !== null) {
|
|
const { data, isStale } = cachedResult;
|
|
const endTime = performance.now();
|
|
|
|
// Debug logging
|
|
if (process.env.CACHE_DEBUG === "true") {
|
|
const icon = isStale ? "⚠️" : "✅";
|
|
const status = isStale ? "STALE" : "HIT";
|
|
logger.debug(
|
|
`${icon} [CACHE ${status}] ${key} | ${type} | ${(endTime - startTime).toFixed(2)}ms`
|
|
);
|
|
}
|
|
|
|
// Si le cache est expiré, revalider en background sans bloquer la réponse
|
|
if (isStale) {
|
|
// Fire and forget - revalidate en background
|
|
this.revalidateInBackground(cacheKey, fetcher, type, key);
|
|
}
|
|
|
|
return data as T;
|
|
}
|
|
|
|
// Pas de cache du tout, fetch normalement
|
|
if (process.env.CACHE_DEBUG === "true") {
|
|
logger.debug(`❌ [CACHE MISS] ${key} | ${type}`);
|
|
}
|
|
|
|
try {
|
|
const data = await fetcher();
|
|
this.set(cacheKey, data, type);
|
|
|
|
const endTime = performance.now();
|
|
if (process.env.CACHE_DEBUG === "true") {
|
|
logger.debug(`💾 [CACHE SET] ${key} | ${type} | ${(endTime - startTime).toFixed(2)}ms`);
|
|
}
|
|
|
|
return data;
|
|
} catch (error) {
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Revalide le cache en background
|
|
*/
|
|
private async revalidateInBackground<T>(
|
|
cacheKey: string,
|
|
fetcher: () => Promise<T>,
|
|
type: keyof typeof ServerCacheService.DEFAULT_TTL,
|
|
debugKey: string
|
|
): Promise<void> {
|
|
try {
|
|
const startTime = performance.now();
|
|
const data = await fetcher();
|
|
this.set(cacheKey, data, type);
|
|
|
|
if (process.env.CACHE_DEBUG === "true") {
|
|
const endTime = performance.now();
|
|
logger.debug(
|
|
`🔄 [CACHE REVALIDATE] ${debugKey} | ${type} | ${(endTime - startTime).toFixed(2)}ms`
|
|
);
|
|
}
|
|
} catch (error) {
|
|
logger.error({ err: error, key: debugKey }, `🔴 [CACHE REVALIDATE ERROR] ${debugKey}`);
|
|
// Ne pas relancer l'erreur car c'est en background
|
|
}
|
|
}
|
|
|
|
invalidate(key: string): void {
|
|
this.delete(key);
|
|
}
|
|
|
|
/**
|
|
* Calcule la taille approximative d'un objet en mémoire
|
|
*/
|
|
private calculateObjectSize(obj: unknown): number {
|
|
if (obj === null || obj === undefined) return 0;
|
|
|
|
// Si c'est un Buffer, utiliser sa taille réelle
|
|
if (Buffer.isBuffer(obj)) {
|
|
return obj.length;
|
|
}
|
|
|
|
// Si c'est un objet avec une propriété buffer (comme ImageResponse)
|
|
if (typeof obj === "object" && obj !== null) {
|
|
const objAny = obj as any;
|
|
if (objAny.buffer && Buffer.isBuffer(objAny.buffer)) {
|
|
// Taille du buffer + taille approximative des autres propriétés
|
|
let size = objAny.buffer.length;
|
|
// Ajouter la taille du contentType si présent
|
|
if (objAny.contentType && typeof objAny.contentType === "string") {
|
|
size += objAny.contentType.length * 2; // UTF-16
|
|
}
|
|
return size;
|
|
}
|
|
}
|
|
|
|
// Pour les autres types, utiliser JSON.stringify comme approximation
|
|
try {
|
|
return JSON.stringify(obj).length * 2; // x2 pour UTF-16
|
|
} catch {
|
|
// Si l'objet n'est pas sérialisable, retourner une estimation
|
|
return 1000; // 1KB par défaut
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calcule la taille du cache
|
|
*/
|
|
async getCacheSize(): Promise<{ sizeInBytes: number; itemCount: number }> {
|
|
if (this.config.mode === "memory") {
|
|
// Calculer la taille approximative en mémoire
|
|
let sizeInBytes = 0;
|
|
let itemCount = 0;
|
|
|
|
this.memoryCache.forEach((value) => {
|
|
if (value.expiry > Date.now()) {
|
|
itemCount++;
|
|
// Calculer la taille du data + expiry (8 bytes pour le timestamp)
|
|
sizeInBytes += this.calculateObjectSize(value.data) + 8;
|
|
}
|
|
});
|
|
|
|
return { sizeInBytes, itemCount };
|
|
}
|
|
|
|
// Calculer la taille du cache sur disque
|
|
let sizeInBytes = 0;
|
|
let itemCount = 0;
|
|
|
|
const calculateDirectorySize = (dirPath: string): void => {
|
|
if (!fs.existsSync(dirPath)) return;
|
|
|
|
const items = fs.readdirSync(dirPath);
|
|
|
|
for (const item of items) {
|
|
const itemPath = path.join(dirPath, item);
|
|
try {
|
|
const stats = fs.statSync(itemPath);
|
|
|
|
if (stats.isDirectory()) {
|
|
calculateDirectorySize(itemPath);
|
|
} else if (stats.isFile() && item.endsWith(".json")) {
|
|
sizeInBytes += stats.size;
|
|
itemCount++;
|
|
}
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Could not access ${itemPath}`);
|
|
}
|
|
}
|
|
};
|
|
|
|
if (fs.existsSync(this.cacheDir)) {
|
|
calculateDirectorySize(this.cacheDir);
|
|
}
|
|
|
|
return { sizeInBytes, itemCount };
|
|
}
|
|
|
|
/**
|
|
* Liste les entrées du cache avec leurs détails
|
|
*/
|
|
async getCacheEntries(): Promise<
|
|
Array<{
|
|
key: string;
|
|
size: number;
|
|
expiry: number;
|
|
isExpired: boolean;
|
|
}>
|
|
> {
|
|
const entries: Array<{
|
|
key: string;
|
|
size: number;
|
|
expiry: number;
|
|
isExpired: boolean;
|
|
}> = [];
|
|
|
|
if (this.config.mode === "memory") {
|
|
this.memoryCache.forEach((value, key) => {
|
|
const size = this.calculateObjectSize(value.data) + 8;
|
|
entries.push({
|
|
key,
|
|
size,
|
|
expiry: value.expiry,
|
|
isExpired: value.expiry <= Date.now(),
|
|
});
|
|
});
|
|
} else {
|
|
const collectEntries = (dirPath: string): void => {
|
|
if (!fs.existsSync(dirPath)) return;
|
|
|
|
const items = fs.readdirSync(dirPath);
|
|
|
|
for (const item of items) {
|
|
const itemPath = path.join(dirPath, item);
|
|
try {
|
|
const stats = fs.statSync(itemPath);
|
|
|
|
if (stats.isDirectory()) {
|
|
collectEntries(itemPath);
|
|
} else if (stats.isFile() && item.endsWith(".json")) {
|
|
try {
|
|
const content = fs.readFileSync(itemPath, "utf-8");
|
|
const cached = JSON.parse(content);
|
|
const key = path.relative(this.cacheDir, itemPath).slice(0, -5);
|
|
|
|
entries.push({
|
|
key,
|
|
size: stats.size,
|
|
expiry: cached.expiry,
|
|
isExpired: cached.expiry <= Date.now(),
|
|
});
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Could not parse file ${itemPath}`);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
logger.error({ err: error, path: itemPath }, `Could not access ${itemPath}`);
|
|
}
|
|
}
|
|
};
|
|
|
|
if (fs.existsSync(this.cacheDir)) {
|
|
collectEntries(this.cacheDir);
|
|
}
|
|
}
|
|
|
|
return entries.sort((a, b) => b.expiry - a.expiry);
|
|
}
|
|
}
|
|
|
|
// Créer une instance initialisée du service
|
|
let initializedInstance: Promise<ServerCacheService>;
|
|
|
|
export const getServerCacheService = async (): Promise<ServerCacheService> => {
|
|
if (!initializedInstance) {
|
|
initializedInstance = ServerCacheService.getInstance();
|
|
}
|
|
return initializedInstance;
|
|
};
|
|
|
|
// Exporter aussi la classe pour les tests
|
|
export { ServerCacheService };
|