feat: implement advanced settings for user preferences, allowing configuration of max concurrent requests, reader prefetch count, and circuit breaker settings

src/lib/services/base-api.service.ts

@@ -9,6 +9,7 @@ import type { ServerCacheService } from "./server-cache.service";
 import { RequestMonitorService } from "./request-monitor.service";
 import { RequestQueueService } from "./request-queue.service";
 import { CircuitBreakerService } from "./circuit-breaker.service";
+import { PreferencesService } from "./preferences.service";
 
 export type { CacheType };
 
@@ -23,7 +24,71 @@ interface KomgaUrlBuilder {
 }
 
 export abstract class BaseApiService {
+  private static requestQueueInitialized = false;
+  private static circuitBreakerInitialized = false;
+
+  /**
+   * Initialise le RequestQueueService avec les préférences de l'utilisateur
+   */
+  private static async initializeRequestQueue(): Promise<void> {
+    if (this.requestQueueInitialized) {
+      return;
+    }
+
+    try {
+      // Configurer le getter qui récupère dynamiquement la valeur depuis les préférences
+      RequestQueueService.setMaxConcurrentGetter(async () => {
+        try {
+          const preferences = await PreferencesService.getPreferences();
+          return preferences.komgaMaxConcurrentRequests;
+        } catch (error) {
+          console.error('Failed to get preferences for request queue:', error);
+          return 5; // Valeur par défaut
+        }
+      });
+      
+      this.requestQueueInitialized = true;
+    } catch (error) {
+      console.error('Failed to initialize request queue:', error);
+    }
+  }
+
+  /**
+   * Initialise le CircuitBreakerService avec les préférences de l'utilisateur
+   */
+  private static async initializeCircuitBreaker(): Promise<void> {
+    if (this.circuitBreakerInitialized) {
+      return;
+    }
+
+    try {
+      // Configurer le getter qui récupère dynamiquement la config depuis les préférences
+      CircuitBreakerService.setConfigGetter(async () => {
+        try {
+          const preferences = await PreferencesService.getPreferences();
+          return preferences.circuitBreakerConfig;
+        } catch (error) {
+          console.error('Failed to get preferences for circuit breaker:', error);
+          return {
+            threshold: 5,
+            timeout: 30000,
+            resetTimeout: 60000,
+          };
+        }
+      });
+      
+      this.circuitBreakerInitialized = true;
+    } catch (error) {
+      console.error('Failed to initialize circuit breaker:', error);
+    }
+  }
+
   protected static async getKomgaConfig(): Promise<AuthConfig> {
+    // Initialiser les services si ce n'est pas déjà fait
+    await Promise.all([
+      this.initializeRequestQueue(),
+      this.initializeCircuitBreaker(),
+    ]);
     try {
       const config: KomgaConfig | null = await ConfigDBService.getConfig();
       if (!config) {

src/lib/services/circuit-breaker.service.ts

@@ -2,6 +2,8 @@
  * Circuit Breaker pour éviter de surcharger Komga quand il est défaillant
  * Évite l'effet avalanche en coupant les requêtes vers un service défaillant
  */
+import type { CircuitBreakerConfig } from "@/types/preferences";
+
 interface CircuitBreakerState {
   state: 'CLOSED' | 'OPEN' | 'HALF_OPEN';
   failureCount: number;
@@ -17,13 +19,44 @@ class CircuitBreaker {
     nextAttemptTime: 0,
   };
 
-  private readonly config = {
+  private config = {
     failureThreshold: 5, // Nombre d'échecs avant ouverture
     recoveryTimeout: 30000, // 30s avant tentative de récupération
-    successThreshold: 3, // Nombre de succès pour fermer le circuit
+    resetTimeout: 60000, // Délai de reset après échec
   };
 
+  private getConfigFromPreferences: (() => Promise<CircuitBreakerConfig>) | null = null;
+
+  /**
+   * Configure une fonction pour récupérer dynamiquement la config depuis les préférences
+   */
+  setConfigGetter(getter: () => Promise<CircuitBreakerConfig>): void {
+    this.getConfigFromPreferences = getter;
+  }
+
+  /**
+   * Récupère la config actuelle, soit depuis les préférences, soit depuis les valeurs par défaut
+   */
+  private async getCurrentConfig(): Promise<typeof this.config> {
+    if (this.getConfigFromPreferences) {
+      try {
+        const prefConfig = await this.getConfigFromPreferences();
+        return {
+          failureThreshold: prefConfig.threshold ?? 5,
+          recoveryTimeout: prefConfig.timeout ?? 30000,
+          resetTimeout: prefConfig.resetTimeout ?? 60000,
+        };
+      } catch (error) {
+        console.error('Error getting circuit breaker config from preferences:', error);
+        return this.config;
+      }
+    }
+    return this.config;
+  }
+
   async execute<T>(operation: () => Promise<T>): Promise<T> {
+    const config = await this.getCurrentConfig();
+    
     if (this.state.state === 'OPEN') {
       if (Date.now() < this.state.nextAttemptTime) {
         throw new Error('Circuit breaker is OPEN - Komga service unavailable');
@@ -36,7 +69,7 @@ class CircuitBreaker {
       this.onSuccess();
       return result;
     } catch (error) {
-      this.onFailure();
+      await this.onFailure(config);
       throw error;
     }
   }
@@ -50,14 +83,14 @@ class CircuitBreaker {
     }
   }
 
-  private onFailure(): void {
+  private async onFailure(config: typeof this.config): Promise<void> {
     this.state.failureCount++;
     this.state.lastFailureTime = Date.now();
 
-    if (this.state.failureCount >= this.config.failureThreshold) {
+    if (this.state.failureCount >= config.failureThreshold) {
       this.state.state = 'OPEN';
-      this.state.nextAttemptTime = Date.now() + this.config.recoveryTimeout;
-      console.warn(`[CIRCUIT-BREAKER] 🔴 Circuit OPEN - Komga failing (${this.state.failureCount} failures)`);
+      this.state.nextAttemptTime = Date.now() + config.resetTimeout;
+      console.warn(`[CIRCUIT-BREAKER] 🔴 Circuit OPEN - Komga failing (${this.state.failureCount} failures, reset in ${config.resetTimeout}ms)`);
     }
   }
 

src/lib/services/preferences.service.ts

@@ -2,7 +2,7 @@ import prisma from "@/lib/prisma";
 import { getCurrentUser } from "../auth-utils";
 import { ERROR_CODES } from "../../constants/errorCodes";
 import { AppError } from "../../utils/errors";
-import type { UserPreferences, BackgroundPreferences } from "@/types/preferences";
+import type { UserPreferences, BackgroundPreferences, CircuitBreakerConfig } from "@/types/preferences";
 import { defaultPreferences } from "@/types/preferences";
 import type { User } from "@/types/komga";
 import type { Prisma } from "@prisma/client";
@@ -35,6 +35,9 @@ export class PreferencesService {
         showOnlyUnread: preferences.showOnlyUnread,
         displayMode: preferences.displayMode as UserPreferences["displayMode"],
         background: preferences.background as unknown as BackgroundPreferences,
+        komgaMaxConcurrentRequests: preferences.komgaMaxConcurrentRequests,
+        readerPrefetchCount: preferences.readerPrefetchCount,
+        circuitBreakerConfig: preferences.circuitBreakerConfig as unknown as CircuitBreakerConfig,
       };
     } catch (error) {
       if (error instanceof AppError) {
@@ -55,6 +58,9 @@ export class PreferencesService {
       if (preferences.showOnlyUnread !== undefined) updateData.showOnlyUnread = preferences.showOnlyUnread;
       if (preferences.displayMode !== undefined) updateData.displayMode = preferences.displayMode;
       if (preferences.background !== undefined) updateData.background = preferences.background;
+      if (preferences.komgaMaxConcurrentRequests !== undefined) updateData.komgaMaxConcurrentRequests = preferences.komgaMaxConcurrentRequests;
+      if (preferences.readerPrefetchCount !== undefined) updateData.readerPrefetchCount = preferences.readerPrefetchCount;
+      if (preferences.circuitBreakerConfig !== undefined) updateData.circuitBreakerConfig = preferences.circuitBreakerConfig;
 
       const updatedPreferences = await prisma.preferences.upsert({
         where: { userId },
@@ -66,9 +72,9 @@ export class PreferencesService {
           showOnlyUnread: preferences.showOnlyUnread ?? defaultPreferences.showOnlyUnread,
           displayMode: preferences.displayMode ?? defaultPreferences.displayMode,
           background: (preferences.background ?? defaultPreferences.background) as unknown as Prisma.InputJsonValue,
-          circuitBreakerConfig: {},
-          komgaMaxConcurrentRequests: 2,
-          readerPrefetchCount: 5,
+          circuitBreakerConfig: (preferences.circuitBreakerConfig ?? defaultPreferences.circuitBreakerConfig) as unknown as Prisma.InputJsonValue,
+          komgaMaxConcurrentRequests: preferences.komgaMaxConcurrentRequests ?? 5,
+          readerPrefetchCount: preferences.readerPrefetchCount ?? 5,
         },
       });
 
@@ -78,6 +84,9 @@ export class PreferencesService {
         showOnlyUnread: updatedPreferences.showOnlyUnread,
         displayMode: updatedPreferences.displayMode as UserPreferences["displayMode"],
         background: updatedPreferences.background as unknown as BackgroundPreferences,
+        komgaMaxConcurrentRequests: updatedPreferences.komgaMaxConcurrentRequests,
+        readerPrefetchCount: updatedPreferences.readerPrefetchCount,
+        circuitBreakerConfig: updatedPreferences.circuitBreakerConfig as unknown as CircuitBreakerConfig,
       };
     } catch (error) {
       if (error instanceof AppError) {

src/lib/services/request-queue.service.ts

@@ -13,11 +13,33 @@ class RequestQueue {
   private queue: QueuedRequest<any>[] = [];
   private activeCount = 0;
   private maxConcurrent: number;
+  private getMaxConcurrent: (() => Promise<number>) | null = null;
 
   constructor(maxConcurrent?: number) {
-    // Lire depuis env ou utiliser la valeur par défaut
-    const envValue = process.env.KOMGA_MAX_CONCURRENT_REQUESTS;
-    this.maxConcurrent = maxConcurrent ?? (envValue ? parseInt(envValue, 10) : 5);
+    // Valeur par défaut
+    this.maxConcurrent = maxConcurrent ?? 5;
+  }
+
+  /**
+   * Configure une fonction pour récupérer dynamiquement le max concurrent depuis les préférences
+   */
+  setMaxConcurrentGetter(getter: () => Promise<number>): void {
+    this.getMaxConcurrent = getter;
+  }
+
+  /**
+   * Récupère la valeur de maxConcurrent, soit depuis les préférences, soit depuis la valeur fixe
+   */
+  private async getCurrentMaxConcurrent(): Promise<number> {
+    if (this.getMaxConcurrent) {
+      try {
+        return await this.getMaxConcurrent();
+      } catch (error) {
+        console.error('Error getting maxConcurrent from preferences, using default:', error);
+        return this.maxConcurrent;
+      }
+    }
+    return this.maxConcurrent;
   }
 
   async enqueue<T>(execute: () => Promise<T>): Promise<T> {
@@ -38,7 +60,8 @@ class RequestQueue {
   }
 
   private async processQueue(): Promise<void> {
-    if (this.activeCount >= this.maxConcurrent || this.queue.length === 0) {
+    const maxConcurrent = await this.getCurrentMaxConcurrent();
+    if (this.activeCount >= maxConcurrent || this.queue.length === 0) {
       return;
     }
 
@@ -77,10 +100,6 @@ class RequestQueue {
   }
 }
 
-// Singleton instance - Par défaut limite à 2 requêtes simultanées (configurable via KOMGA_MAX_CONCURRENT_REQUESTS)
-export const RequestQueueService = new RequestQueue(
-  process.env.KOMGA_MAX_CONCURRENT_REQUESTS 
-    ? parseInt(process.env.KOMGA_MAX_CONCURRENT_REQUESTS, 10) 
-    : 2
-);
+// Singleton instance - Par défaut limite à 5 requêtes simultanées
+export const RequestQueueService = new RequestQueue(5);