opticore-cache 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2565 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_dotenv = __toESM(require("dotenv"), 1);
+
+// src/infrastructure/config/environmentLoader.config.ts
+var EnvironmentLoader = class _EnvironmentLoader {
+  static instance;
+  configuration;
+  /**
+   * Constructeur privé pour forcer l'utilisation de getInstance()
+   */
+  constructor() {
+    this.loadConfiguration();
+  }
+  /**
+   * Récupère l'instance unique du EnvironmentLoader
+   *
+   * @returns EnvironmentLoader
+   */
+  static getInstance() {
+    if (!_EnvironmentLoader.instance) {
+      _EnvironmentLoader.instance = new _EnvironmentLoader();
+    }
+    return _EnvironmentLoader.instance;
+  }
+  /**
+   * Charge et parse la configuration depuis process.env
+   *
+   * @private
+   */
+  loadConfiguration() {
+    this.configuration = {
+      // Activation du cache
+      enabled: this.parseBoolean("CACHE_ENABLED", false),
+      // Configuration de base
+      defaultTTL: this.parseNumber("CACHE_DEFAULT_TTL", 3e5),
+      // 5 minutes
+      maxSize: this.parseNumber("CACHE_MAX_SIZE", 100),
+      evictionStrategy: this.parseEvictionStrategy("CACHE_STRATEGY", "lru"),
+      namespace: process.env.CACHE_NAMESPACE || "opticore-app",
+      // Configuration des routes à ignorer
+      skipRoutes: this.parseSkipRoutes("CACHE_SKIP_ROUTES"),
+      enableWildcards: this.parseBoolean("CACHE_SKIP_WILDCARDS", true),
+      userAware: this.parseBoolean("CACHE_USER_AWARE", false),
+      // Options avancées
+      debug: this.parseBoolean("CACHE_DEBUG", false),
+      // Performance
+      cleanupInterval: this.parseNumber("CACHE_CLEANUP_INTERVAL", 6e4)
+      // 1 minute
+    };
+  }
+  /**
+   * Parse une valeur booléenne depuis les variables d'environnement
+   *
+   * @param key - Clé de la variable d'environnement
+   * @param defaultValue - Valeur par défaut si non définie
+   * @returns boolean
+   */
+  parseBoolean(key, defaultValue) {
+    const value = process.env[key];
+    if (value === void 0) return defaultValue;
+    const normalizedValue = value.toLowerCase().trim();
+    return ["true", "1", "yes", "on"].includes(normalizedValue);
+  }
+  /**
+   * Parse un nombre depuis les variables d'environnement
+   *
+   * @param key - Clé de la variable d'environnement
+   * @param defaultValue - Valeur par défaut si non définie ou invalide
+   * @returns number
+   */
+  parseNumber(key, defaultValue) {
+    const value = process.env[key];
+    if (!value) return defaultValue;
+    const parsed = parseInt(value, 10);
+    return isNaN(parsed) ? defaultValue : parsed;
+  }
+  /**
+   * Parse la stratégie d'éviction depuis les variables d'environnement
+   *
+   * @param key - Clé de la variable d'environnement
+   * @param defaultValue - Valeur par défaut
+   * @returns 'lru' | 'fifo' | 'lfu'
+   */
+  parseEvictionStrategy(key, defaultValue) {
+    const value = process.env[key] || defaultValue;
+    const validStrategies = ["lru", "fifo", "lfu"];
+    return validStrategies.includes(value.toLowerCase()) ? value.toLowerCase() : defaultValue;
+  }
+  /**
+   * Parse la liste des routes à ignorer depuis les variables d'environnement
+   *
+   * @param key - Clé de la variable d'environnement
+   * @returns string[] - Liste des routes à ignorer
+   */
+  parseSkipRoutes(key) {
+    const value = process.env[key];
+    if (!value) return [];
+    return value.split(",").map((route) => route.trim()).filter((route) => route.length > 0);
+  }
+  /**
+   * Récupère la configuration complète
+   *
+   * @returns CacheConfiguration
+   */
+  getConfig() {
+    return { ...this.configuration };
+  }
+  /**
+   * Met à jour la configuration (pour les tests)
+   *
+   * @param updates - Mises à jour partielles de configuration
+   */
+  updateConfig(updates) {
+    this.configuration = { ...this.configuration, ...updates };
+  }
+};
+
+// src/infrastructure/cache/memoryCache.repository.ts
+var MemoryCache = class {
+  /**
+   * Crée une instance de MemoryCache
+   * @param config - Configuration du cache
+   */
+  constructor(config) {
+    this.config = config;
+    this.statistics.maxSize = config.maxSize;
+    this.startCleanupCycle();
+  }
+  store = /* @__PURE__ */ new Map();
+  statistics = {
+    hits: 0,
+    misses: 0,
+    writes: 0,
+    size: 0,
+    maxSize: 0
+  };
+  cleanupInterval;
+  /**
+   * Stocke une valeur dans le cache
+   * @param key - Clé unique pour l'entrée
+   * @param value - Valeur à stocker
+   * @param ttl - Durée de vie en millisecondes
+   * @returns Promise<void>
+   */
+  async set(key, value, ttl) {
+    const now = Date.now();
+    const timeToLive = ttl || this.config.defaultTTL;
+    const entry = {
+      key,
+      value,
+      timeToLive,
+      createdAt: now,
+      expiresAt: now + timeToLive,
+      accessCount: 0,
+      lastAccessedAt: now
+    };
+    if (this.store.size >= this.config.maxSize) {
+      this.evictEntry();
+    }
+    this.store.set(key, entry);
+    this.statistics.writes++;
+    this.statistics.size = this.store.size;
+  }
+  /**
+   * Récupère une valeur depuis le cache
+   * @param key - Clé de l'entrée à récupérer
+   * @returns Promise<T | null>
+   */
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      this.statistics.misses++;
+      return null;
+    }
+    const now = Date.now();
+    if (now > entry.expiresAt) {
+      await this.delete(key);
+      this.statistics.misses++;
+      return null;
+    }
+    entry.accessCount++;
+    entry.lastAccessedAt = now;
+    if (this.config.evictionStrategy === "lru") {
+      this.store.delete(key);
+      this.store.set(key, entry);
+    }
+    this.statistics.hits++;
+    return entry.value;
+  }
+  /**
+   * Supprime une entrée du cache
+   *
+   * @param key - Clé de l'entrée à supprimer
+   * @returns Promise<void>
+   */
+  async delete(key) {
+    this.store.delete(key);
+    this.statistics.size = this.store.size;
+  }
+  /**
+   * Vérifie si une clé existe dans le cache
+   *
+   * @param key - Clé à vérifier
+   * @returns Promise<boolean>
+   */
+  async has(key) {
+    const entry = this.store.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      await this.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Supprime toutes les entrées du cache
+   *
+   * @returns Promise<void>
+   */
+  async clear() {
+    this.store.clear();
+    this.statistics = {
+      hits: 0,
+      misses: 0,
+      writes: 0,
+      size: 0,
+      maxSize: this.config.maxSize
+    };
+  }
+  /**
+   * Récupère toutes les clés valides du cache
+   *
+   * @returns Promise<string[]>
+   */
+  async keys() {
+    const expiredKeys = [];
+    for (const [key, entry] of this.store.entries()) {
+      if (Date.now() > entry.expiresAt) {
+        expiredKeys.push(key);
+      }
+    }
+    for (const key of expiredKeys) {
+      await this.delete(key);
+    }
+    return Array.from(this.store.keys());
+  }
+  /**
+   * Récupère les statistiques d'utilisation du cache
+   *
+   * @returns Promise<CacheStatistics>
+   */
+  async getStatistics() {
+    const totalRequests = this.statistics.hits + this.statistics.misses;
+    const hitRate = totalRequests > 0 ? this.statistics.hits / totalRequests * 100 : 0;
+    const usagePercentage = this.statistics.maxSize > 0 ? this.statistics.size / this.statistics.maxSize * 100 : 0;
+    return {
+      ...this.statistics,
+      hitRate: parseFloat(hitRate.toFixed(2)),
+      usagePercentage: parseFloat(usagePercentage.toFixed(2))
+    };
+  }
+  /**
+   * Invalide les entrées dont la clé correspond au pattern
+   *
+   * @param pattern - Pattern de clés à invalider
+   * @returns Promise<number> - Nombre d'entrées invalidées
+   */
+  async invalidate(pattern) {
+    const keysToDelete = [];
+    const patternRegex = new RegExp(pattern.replace("*", ".*"));
+    for (const key of this.store.keys()) {
+      if (patternRegex.test(key)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      await this.delete(key);
+    }
+    return keysToDelete.length;
+  }
+  /**
+   * Évince une entrée selon la stratégie configurée
+   *
+   * @private
+   */
+  evictEntry() {
+    if (this.store.size === 0) return;
+    let keyToEvict = null;
+    switch (this.config.evictionStrategy) {
+      case "lru":
+        keyToEvict = this.findLRUKey();
+        break;
+      case "fifo":
+        keyToEvict = this.findFIFOKey();
+        break;
+      case "lfu":
+        keyToEvict = this.findLFUKey();
+        break;
+    }
+    if (keyToEvict) {
+      this.store.delete(keyToEvict);
+      this.statistics.size = this.store.size;
+    }
+  }
+  /**
+   * Trouve la clé la moins récemment utilisée (LRU)
+   *
+   * @private
+   * @returns string | null
+   */
+  findLRUKey() {
+    let oldestKey = null;
+    let oldestTime = Date.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.lastAccessedAt < oldestTime) {
+        oldestTime = entry.lastAccessedAt;
+        oldestKey = key;
+      }
+    }
+    return oldestKey;
+  }
+  /**
+   * Trouve la clé la première entrée insérée (FIFO)
+   *
+   * @private
+   * @returns string | null
+   */
+  findFIFOKey() {
+    return this.store.keys().next().value || null;
+  }
+  /**
+   * Trouve la clé la moins fréquemment utilisée (LFU)
+   *
+   * @private
+   * @returns string | null
+   */
+  findLFUKey() {
+    let leastFrequentKey = null;
+    let leastAccessCount = Infinity;
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.accessCount < leastAccessCount) {
+        leastAccessCount = entry.accessCount;
+        leastFrequentKey = key;
+      }
+    }
+    return leastFrequentKey;
+  }
+  /**
+   * Démarre le cycle de nettoyage des entrées expirées
+   *
+   * @private
+   */
+  startCleanupCycle() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpiredEntries();
+    }, this.config.cleanupInterval || 6e4);
+  }
+  /**
+   * Nettoie les entrées expirées du cache
+   *
+   * @private
+   */
+  cleanupExpiredEntries() {
+    const now = Date.now();
+    const expiredKeys = [];
+    for (const [key, entry] of this.store.entries()) {
+      if (now > entry.expiresAt) {
+        expiredKeys.push(key);
+      }
+    }
+    expiredKeys.forEach((key) => {
+      this.store.delete(key);
+    });
+    if (expiredKeys.length > 0) {
+      this.statistics.size = this.store.size;
+      if (this.config.debug) {
+        console.log(`[Cache] Cleaned up ${expiredKeys.length} expired entries`);
+      }
+    }
+  }
+  /**
+   * Arrête le cache et libère les ressources
+   */
+  dispose() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = void 0;
+    }
+    this.store.clear();
+  }
+};
+
+// src/infrastructure/cache/diskCache.repository.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_util = require("util");
+var fsExists = (0, import_util.promisify)(import_fs.default.exists);
+var fsMkdir = (0, import_util.promisify)(import_fs.default.mkdir);
+var fsReadFile = (0, import_util.promisify)(import_fs.default.readFile);
+var fsWriteFile = (0, import_util.promisify)(import_fs.default.writeFile);
+var fsUnlink = (0, import_util.promisify)(import_fs.default.unlink);
+var fsReaddir = (0, import_util.promisify)(import_fs.default.readdir);
+var DiskCache = class {
+  /**
+   * Crée une instance de DiskCache
+   * @param config - Configuration du cache
+   */
+  constructor(config) {
+    this.config = config;
+    this.statistics.maxSize = config.maxSize;
+    this.cacheDir = this.getCacheDirectory();
+    try {
+      if (!import_fs.default.existsSync(this.cacheDir)) {
+        import_fs.default.mkdirSync(this.cacheDir, { recursive: true });
+        if (this.config.debug) {
+          console.log(`[DiskCache] Dossier cr\xE9\xE9: ${this.cacheDir}`);
+        }
+      }
+    } catch (error) {
+      console.error(`[DiskCache] Erreur cr\xE9ation du dossier: ${error.message}`);
+    }
+    this.loadIndexFromDisk().catch((err) => {
+      console.error("[DiskCache] Erreur chargement index:", err);
+    });
+    this.startCleanupCycle();
+  }
+  cacheDir;
+  statistics = {
+    hits: 0,
+    misses: 0,
+    writes: 0,
+    size: 0,
+    maxSize: 0
+  };
+  memoryIndex = /* @__PURE__ */ new Map();
+  cleanupInterval;
+  /**
+   * Détermine le répertoire de cache
+   * @private
+   */
+  getCacheDirectory() {
+    return process.env.CACHE_DISK_DIR || import_path.default.join(process.cwd(), "storage", "cache", this.config.namespace);
+  }
+  /**
+   * Initialise le répertoire de cache
+   * @private
+   */
+  async initializeCacheDirectory() {
+    try {
+      if (!await fsExists(this.cacheDir)) {
+        await fsMkdir(this.cacheDir, { recursive: true });
+        if (this.config.debug) {
+          console.log(`[DiskCache] Dossier cr\xE9\xE9: ${this.cacheDir}`);
+        }
+      }
+      const readmePath = import_path.default.join(this.cacheDir, "README.txt");
+      if (!await fsExists(readmePath)) {
+        const readmeContent = `# Cache Directory - ${this.config.namespace}
+        
+Ce dossier contient les fichiers de cache persist\xE9s sur disque.
+Chaque fichier repr\xE9sente une entr\xE9e de cache avec sa valeur et m\xE9tadonn\xE9es.
+
+Structure:
+- ${this.config.namespace}_*.json : Fichiers de donn\xE9es de cache
+- index.json : Index des cl\xE9s de cache (charg\xE9 en m\xE9moire)
+
+NE PAS SUPPRIMER MANUELLEMENT ces fichiers pendant l'ex\xE9cution du serveur.
+`;
+        await fsWriteFile(readmePath, readmeContent, "utf8");
+      }
+    } catch (error) {
+      console.error(`[DiskCache] Erreur d'initialisation du dossier: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Charge l'index des clés depuis le disque
+   * @private
+   */
+  async loadIndexFromDisk() {
+    try {
+      const indexPath = import_path.default.join(this.cacheDir, "index.json");
+      if (await fsExists(indexPath)) {
+        const indexData = await fsReadFile(indexPath, "utf8");
+        const index = JSON.parse(indexData);
+        for (const [key, info] of Object.entries(index)) {
+          this.memoryIndex.set(key, info);
+        }
+        this.statistics.size = this.memoryIndex.size;
+        if (this.config.debug) {
+          console.log(`[DiskCache] Index charg\xE9: ${this.memoryIndex.size} entr\xE9es`);
+        }
+      } else {
+        await this.saveIndexToDisk();
+      }
+    } catch (error) {
+      console.error(`[DiskCache] Erreur de chargement de l'index: ${error.message}`);
+    }
+  }
+  /**
+   * Sauvegarde l'index sur le disque
+   * @private
+   */
+  async saveIndexToDisk() {
+    try {
+      const indexPath = import_path.default.join(this.cacheDir, "index.json");
+      const indexObject = {};
+      for (const [key, info] of this.memoryIndex.entries()) {
+        indexObject[key] = info;
+      }
+      await fsWriteFile(indexPath, JSON.stringify(indexObject, null, 2), "utf8");
+    } catch (error) {
+      console.error(`[DiskCache] Erreur de sauvegarde de l'index: ${error.message}`);
+    }
+  }
+  /**
+   * Génère un nom de fichier sécurisé pour une clé
+   * @param key - Clé de cache
+   * @returns string - Nom de fichier
+   * @private
+   */
+  keyToFilename(key) {
+    const safeKey = key.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+    return `${this.config.namespace}_${safeKey}.json`;
+  }
+  /**
+   * Génère le chemin complet du fichier
+   * @param key - Clé de cache
+   * @returns string - Chemin du fichier
+   * @private
+   */
+  keyToFilePath(key) {
+    const filename = this.keyToFilename(key);
+    return import_path.default.join(this.cacheDir, filename);
+  }
+  /**
+   * Stocke une valeur dans le cache
+   */
+  async set(key, value, ttl) {
+    const now = Date.now();
+    const timeToLive = ttl || this.config.defaultTTL;
+    const expiresAt = now + timeToLive;
+    const entry = {
+      key,
+      value,
+      timeToLive,
+      createdAt: now,
+      expiresAt,
+      accessCount: 0,
+      lastAccessedAt: now
+    };
+    if (this.memoryIndex.size >= this.config.maxSize) {
+      await this.evictEntry();
+    }
+    const filePath = this.keyToFilePath(key);
+    try {
+      await fsWriteFile(filePath, JSON.stringify(entry, null, 2), "utf8");
+      this.memoryIndex.set(key, { filePath, expiresAt });
+      await this.saveIndexToDisk();
+      this.statistics.writes++;
+      this.statistics.size = this.memoryIndex.size;
+      if (this.config.debug) {
+        console.log(`[DiskCache] \xC9criture: ${key} -> ${filePath}`);
+      }
+    } catch (error) {
+      console.error(`[DiskCache] Erreur d'\xE9criture pour ${key}:`, error.message);
+      throw error;
+    }
+  }
+  /**
+   * Récupère une valeur depuis le cache
+   */
+  async get(key) {
+    const entryInfo = this.memoryIndex.get(key);
+    if (!entryInfo) {
+      this.statistics.misses++;
+      return null;
+    }
+    const now = Date.now();
+    if (now > entryInfo.expiresAt) {
+      await this.delete(key);
+      this.statistics.misses++;
+      return null;
+    }
+    try {
+      const fileContent = await fsReadFile(entryInfo.filePath, "utf8");
+      const entry = JSON.parse(fileContent);
+      if (now > entry.expiresAt) {
+        await this.delete(key);
+        this.statistics.misses++;
+        return null;
+      }
+      entry.accessCount++;
+      entry.lastAccessedAt = now;
+      await fsWriteFile(entryInfo.filePath, JSON.stringify(entry, null, 2), "utf8");
+      if (this.config.evictionStrategy === "lru") {
+        await fsWriteFile(entryInfo.filePath, JSON.stringify(entry, null, 2), "utf8");
+      }
+      this.statistics.hits++;
+      if (this.config.debug) {
+        console.log(`[DiskCache] Lecture: ${key} (acc\xE8s: ${entry.accessCount})`);
+      }
+      return entry.value;
+    } catch (error) {
+      console.error(`[DiskCache] Erreur de lecture pour ${key}:`, error.message);
+      await this.delete(key);
+      this.statistics.misses++;
+      return null;
+    }
+  }
+  /**
+   * Supprime une entrée du cache
+   */
+  async delete(key) {
+    const entryInfo = this.memoryIndex.get(key);
+    if (entryInfo) {
+      try {
+        if (await fsExists(entryInfo.filePath)) {
+          await fsUnlink(entryInfo.filePath);
+        }
+        this.memoryIndex.delete(key);
+        await this.saveIndexToDisk();
+        this.statistics.size = this.memoryIndex.size;
+        if (this.config.debug) {
+          console.log(`[DiskCache] Suppression: ${key}`);
+        }
+      } catch (error) {
+        console.error(`[DiskCache] Erreur de suppression pour ${key}:`, error.message);
+      }
+    }
+  }
+  /**
+   * Vérifie si une clé existe dans le cache
+   */
+  async has(key) {
+    const entryInfo = this.memoryIndex.get(key);
+    if (!entryInfo) {
+      return false;
+    }
+    if (Date.now() > entryInfo.expiresAt) {
+      await this.delete(key);
+      return false;
+    }
+    return await fsExists(entryInfo.filePath);
+  }
+  /**
+   * Supprime toutes les entrées du cache
+   */
+  async clear() {
+    try {
+      const files = await fsReaddir(this.cacheDir);
+      const cacheFiles = files.filter(
+        (file) => file.startsWith(`${this.config.namespace}_`) && file.endsWith(".json")
+      );
+      for (const file of cacheFiles) {
+        const filePath = import_path.default.join(this.cacheDir, file);
+        await fsUnlink(filePath);
+      }
+      const indexPath = import_path.default.join(this.cacheDir, "index.json");
+      if (await fsExists(indexPath)) {
+        await fsUnlink(indexPath);
+      }
+      this.memoryIndex.clear();
+      this.statistics = {
+        hits: 0,
+        misses: 0,
+        writes: 0,
+        size: 0,
+        maxSize: this.config.maxSize
+      };
+      await this.saveIndexToDisk();
+      if (this.config.debug) {
+        console.log(`[DiskCache] Cache vid\xE9: ${cacheFiles.length} fichiers supprim\xE9s`);
+      }
+    } catch (error) {
+      console.error(`[DiskCache] Erreur lors du vidage:`, error.message);
+      throw error;
+    }
+  }
+  /**
+   * Récupère toutes les clés valides du cache
+   */
+  async keys() {
+    await this.cleanupExpiredEntries();
+    return Array.from(this.memoryIndex.keys());
+  }
+  /**
+   * Récupère les statistiques d'utilisation du cache
+   */
+  async getStatistics() {
+    const totalRequests = this.statistics.hits + this.statistics.misses;
+    const hitRate = totalRequests > 0 ? this.statistics.hits / totalRequests * 100 : 0;
+    const usagePercentage = this.statistics.maxSize > 0 ? this.statistics.size / this.statistics.maxSize * 100 : 0;
+    return {
+      ...this.statistics,
+      hitRate: parseFloat(hitRate.toFixed(2)),
+      usagePercentage: parseFloat(usagePercentage.toFixed(2))
+    };
+  }
+  /**
+   * Invalide les entrées dont la clé correspond au pattern
+   */
+  async invalidate(pattern) {
+    const patternRegex = new RegExp(pattern.replace("*", ".*"));
+    const keysToDelete = [];
+    for (const key of this.memoryIndex.keys()) {
+      if (patternRegex.test(key)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      await this.delete(key);
+    }
+    return keysToDelete.length;
+  }
+  /**
+   * Évince une entrée selon la stratégie configurée
+   * @private
+   */
+  async evictEntry() {
+    if (this.memoryIndex.size === 0) return;
+    let keyToEvict = null;
+    switch (this.config.evictionStrategy) {
+      case "lru":
+        keyToEvict = await this.findLRUKey();
+        break;
+      case "fifo":
+        keyToEvict = await this.findFIFOKey();
+        break;
+      case "lfu":
+        keyToEvict = await this.findLFUKey();
+        break;
+    }
+    if (keyToEvict) {
+      await this.delete(keyToEvict);
+    }
+  }
+  /**
+   * Trouve la clé la moins récemment utilisée (LRU)
+   * @private
+   */
+  async findLRUKey() {
+    let oldestKey = null;
+    let oldestTime = Date.now();
+    for (const [key, info] of this.memoryIndex.entries()) {
+      try {
+        const filePath = this.keyToFilePath(key);
+        if (await fsExists(filePath)) {
+          const fileContent = await fsReadFile(filePath, "utf8");
+          const entry = JSON.parse(fileContent);
+          if (entry.lastAccessedAt < oldestTime) {
+            oldestTime = entry.lastAccessedAt;
+            oldestKey = key;
+          }
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    return oldestKey;
+  }
+  /**
+   * Trouve la première entrée insérée (FIFO)
+   * @private
+   */
+  async findFIFOKey() {
+    let oldestKey = null;
+    let oldestTime = Date.now();
+    for (const [key, info] of this.memoryIndex.entries()) {
+      try {
+        const filePath = this.keyToFilePath(key);
+        if (await fsExists(filePath)) {
+          const fileContent = await fsReadFile(filePath, "utf8");
+          const entry = JSON.parse(fileContent);
+          if (entry.createdAt < oldestTime) {
+            oldestTime = entry.createdAt;
+            oldestKey = key;
+          }
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    return oldestKey;
+  }
+  /**
+   * Trouve la clé la moins fréquemment utilisée (LFU)
+   * @private
+   */
+  async findLFUKey() {
+    let leastFrequentKey = null;
+    let leastAccessCount = Infinity;
+    for (const [key, info] of this.memoryIndex.entries()) {
+      try {
+        const filePath = this.keyToFilePath(key);
+        if (await fsExists(filePath)) {
+          const fileContent = await fsReadFile(filePath, "utf8");
+          const entry = JSON.parse(fileContent);
+          if (entry.accessCount < leastAccessCount) {
+            leastAccessCount = entry.accessCount;
+            leastFrequentKey = key;
+          }
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    return leastFrequentKey;
+  }
+  /**
+   * Démarre le cycle de nettoyage des entrées expirées
+   * @private
+   */
+  startCleanupCycle() {
+    this.cleanupExpiredEntries();
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpiredEntries();
+    }, this.config.cleanupInterval);
+    if (this.config.debug) {
+      console.log(`[DiskCache] Cycle de nettoyage: ${this.config.cleanupInterval}ms`);
+    }
+  }
+  /**
+   * Nettoie les entrées expirées du cache
+   * @private
+   */
+  async cleanupExpiredEntries() {
+    const now = Date.now();
+    const expiredKeys = [];
+    for (const [key, info] of this.memoryIndex.entries()) {
+      if (now > info.expiresAt) {
+        expiredKeys.push(key);
+      }
+    }
+    for (const key of expiredKeys) {
+      await this.delete(key);
+    }
+    if (expiredKeys.length > 0 && this.config.debug) {
+      console.log(`[DiskCache] Nettoyage: ${expiredKeys.length} entr\xE9es expir\xE9es`);
+    }
+  }
+  /**
+   * Récupère le chemin du dossier de cache
+   * @returns string
+   */
+  getCacheDirectoryPath() {
+    return this.cacheDir;
+  }
+  /**
+   * Liste tous les fichiers de cache
+   * @returns Promise<string[]> - Liste des chemins de fichiers
+   */
+  async listCacheFiles() {
+    try {
+      const files = await fsReaddir(this.cacheDir);
+      return files.filter((file) => file.startsWith(`${this.config.namespace}_`) && file.endsWith(".json")).map((file) => import_path.default.join(this.cacheDir, file));
+    } catch (error) {
+      console.error(`[DiskCache] Erreur de listing:`, error.message);
+      return [];
+    }
+  }
+  /**
+   * Récupère les informations d'un fichier de cache
+   * @param key - Clé de cache
+   * @returns Promise<CacheEntry | null>
+   */
+  async inspectCacheFile(key) {
+    try {
+      const filePath = this.keyToFilePath(key);
+      if (await fsExists(filePath)) {
+        const content = await fsReadFile(filePath, "utf8");
+        return JSON.parse(content);
+      }
+      return null;
+    } catch (error) {
+      console.error(`[DiskCache] Erreur d'inspection:`, error.message);
+      return null;
+    }
+  }
+  /**
+   * Arrête le cache et libère les ressources
+   */
+  dispose() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = void 0;
+    }
+    this.saveIndexToDisk().catch(console.error);
+  }
+};
+
+// src/infrastructure/cache/hybridCache.repository.ts
+var HybridCache = class {
+  l1Cache;
+  // Premier niveau (mémoire)
+  l2Cache;
+  // Deuxième niveau (disque)
+  statistics = {
+    l1Hits: 0,
+    l2Hits: 0,
+    misses: 0,
+    writes: 0,
+    promotions: 0
+    // Nombre de fois où on a promu L2 → L1
+  };
+  config;
+  constructor(config) {
+    this.config = config;
+    this.l1Cache = new MemoryCache({
+      ...config,
+      maxSize: Math.floor(config.maxSize * 0.2)
+      // L1: 20% de la capacité totale
+    });
+    this.l2Cache = new DiskCache({
+      ...config,
+      maxSize: Math.floor(config.maxSize * 0.8)
+      // L2: 80% de la capacité totale
+    });
+  }
+  async set(key, value, ttl) {
+    try {
+      await this.l2Cache.set(key, value, ttl);
+      try {
+        await this.l1Cache.set(key, value, ttl);
+      } catch (l1Error) {
+        if (this.config.debug) {
+          console.log(`[HybridCache] L1 plein pour ${key}, gard\xE9 seulement en L2`);
+        }
+      }
+      this.statistics.writes++;
+    } catch (error) {
+      console.error(`[HybridCache] Erreur set pour ${key}:`, error.message);
+      throw error;
+    }
+  }
+  async get(key) {
+    const l1Value = await this.l1Cache.get(key);
+    if (l1Value !== null) {
+      this.statistics.l1Hits++;
+      if (this.config.debug) {
+        console.log(`[HybridCache] L1 HIT pour ${key}`);
+      }
+      return l1Value;
+    }
+    const l2Value = await this.l2Cache.get(key);
+    if (l2Value !== null) {
+      this.statistics.l2Hits++;
+      try {
+        await this.l1Cache.set(key, l2Value);
+        this.statistics.promotions++;
+        if (this.config.debug) {
+          console.log(`[HybridCache] Promotion L2\u2192L1 pour ${key}`);
+        }
+      } catch (promotionError) {
+        if (this.config.debug) {
+          console.log(`[HybridCache] Pas de promotion pour ${key} (L1 plein)`);
+        }
+      }
+      return l2Value;
+    }
+    this.statistics.misses++;
+    return null;
+  }
+  async delete(key) {
+    await Promise.all([
+      this.l1Cache.delete(key).catch(() => {
+      }),
+      // Ignorer les erreurs L1
+      this.l2Cache.delete(key)
+    ]);
+  }
+  async has(key) {
+    if (await this.l1Cache.has(key)) {
+      return true;
+    }
+    return await this.l2Cache.has(key);
+  }
+  async clear() {
+    await Promise.all([
+      this.l1Cache.clear(),
+      this.l2Cache.clear()
+    ]);
+    this.statistics = {
+      l1Hits: 0,
+      l2Hits: 0,
+      misses: 0,
+      writes: 0,
+      promotions: 0
+    };
+  }
+  async keys() {
+    const [l1Keys, l2Keys] = await Promise.all([
+      this.l1Cache.keys(),
+      this.l2Cache.keys()
+    ]);
+    const allKeys = /* @__PURE__ */ new Set([...l1Keys, ...l2Keys]);
+    return Array.from(allKeys);
+  }
+  async getStatistics() {
+    const l1Stats = await this.l1Cache.getStatistics();
+    const l2Stats = await this.l2Cache.getStatistics();
+    const totalHits = this.statistics.l1Hits + this.statistics.l2Hits;
+    const totalRequests = totalHits + this.statistics.misses;
+    const hitRate = totalRequests > 0 ? totalHits / totalRequests * 100 : 0;
+    const totalSize = l1Stats.size + l2Stats.size;
+    const totalMaxSize = l1Stats.maxSize + l2Stats.maxSize;
+    const usagePercentage = totalMaxSize > 0 ? totalSize / totalMaxSize * 100 : 0;
+    return {
+      hits: totalHits,
+      misses: this.statistics.misses,
+      writes: this.statistics.writes,
+      size: totalSize,
+      maxSize: totalMaxSize,
+      hitRate: parseFloat(hitRate.toFixed(2)),
+      usagePercentage: parseFloat(usagePercentage.toFixed(2))
+    };
+  }
+  async invalidate(pattern) {
+    const [l1Count, l2Count] = await Promise.all([
+      this.l1Cache.invalidate(pattern),
+      this.l2Cache.invalidate(pattern)
+    ]);
+    return l1Count + l2Count;
+  }
+  /**
+   * Statistiques détaillées du cache hybride
+   */
+  async getDetailedStatistics() {
+    const totalHits = this.statistics.l1Hits + this.statistics.l2Hits;
+    const totalRequests = totalHits + this.statistics.misses;
+    return {
+      performance: {
+        totalRequests,
+        totalHits,
+        misses: this.statistics.misses,
+        overallHitRate: totalRequests > 0 ? (totalHits / totalRequests * 100).toFixed(2) + "%" : "0%",
+        l1HitRate: this.statistics.l1Hits > 0 ? (this.statistics.l1Hits / totalHits * 100).toFixed(2) + "%" : "0%",
+        l2HitRate: this.statistics.l2Hits > 0 ? (this.statistics.l2Hits / totalHits * 100).toFixed(2) + "%" : "0%",
+        promotions: this.statistics.promotions
+      },
+      levels: {
+        l1: await this.l1Cache.getStatistics(),
+        l2: await this.l2Cache.getStatistics()
+      },
+      cache: {
+        l1Size: this.config.maxSize * 0.2,
+        l2Size: this.config.maxSize * 0.8,
+        strategy: this.config.evictionStrategy
+      }
+    };
+  }
+  /**
+   * Synchronise L1 avec L2 (après redémarrage)
+   */
+  async warmupL1FromL2(keysToWarm = []) {
+    let warmedCount = 0;
+    const keys = keysToWarm.length > 0 ? keysToWarm : (await this.l2Cache.keys()).slice(0, 100);
+    for (const key of keys) {
+      try {
+        const value = await this.l2Cache.get(key);
+        if (value !== null) {
+          await this.l1Cache.set(key, value);
+          warmedCount++;
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    if (this.config.debug) {
+      console.log(`[HybridCache] Warmup: ${warmedCount} cl\xE9s charg\xE9es de L2 vers L1`);
+    }
+    return warmedCount;
+  }
+};
+
+// src/infrastructure/cache/cacheFactory.repository.ts
+var CacheFactoryRepository = class {
+  /**
+   * Crée une instance de cache basée sur la configuration
+   *
+   * @param customConfig - Configuration personnalisée (optionnel)
+   * @returns CacheRepository | null - Instance de cache ou null si désactivé
+   */
+  static createCache(customConfig) {
+    const envLoader = EnvironmentLoader.getInstance();
+    const baseConfig = envLoader.getConfig();
+    const config = { ...baseConfig, ...customConfig };
+    if (!config.enabled) {
+      return null;
+    }
+    const storageType = (config.storageType || process.env.CACHE_STORAGE_TYPE || "hybrid").toLowerCase();
+    switch (storageType) {
+      case "memory":
+        return new MemoryCache(config);
+      case "disk":
+        return new DiskCache(config);
+      case "hybrid":
+      default:
+        return new HybridCache(config);
+    }
+  }
+  /**
+   * Crée un cache avec une configuration minimale
+   *
+   * @param enabled - Activer le cache
+   * @param maxSize - Taille maximale
+   * @returns CacheRepository | null
+   */
+  static createSimpleCache(enabled, maxSize = 100) {
+    const envLoader = EnvironmentLoader.getInstance();
+    const baseConfig = envLoader.getConfig();
+    return this.createCache({ ...baseConfig, enabled, maxSize });
+  }
+};
+
+// src/core/usecases/cacheManagement.usecase.ts
+var CacheManagementUseCase = class {
+  /**
+   * Creates an instance of CacheManagementUseCase
+   *
+   * @param cacheRepository - Injected cache repository
+   */
+  constructor(cacheRepository) {
+    this.cacheRepository = cacheRepository;
+  }
+  /**
+   * Retrieves a value from cache or adds it if missing
+   * "Cache-Aside" / "Lazy Loading" pattern
+   *
+   * @param key - Entry key
+   * @param fetcher - Async function to fetch the value if missing
+   * @param ttl - Specific time to live (optional)
+   * @returns Promise<T> - Value from cache or fetcher result
+   */
+  async getOrSet(key, fetcher, ttl) {
+    const cachedValue = await this.cacheRepository.get(key);
+    if (cachedValue !== null) {
+      return cachedValue;
+    }
+    const freshValue = await fetcher();
+    await this.cacheRepository.set(key, freshValue, ttl);
+    return freshValue;
+  }
+  /**
+   * Invalidates all entries matching the pattern
+   *
+   * @param pattern - Pattern to select entries to invalidate
+   * @returns Promise<number> - Number of invalidated entries
+   */
+  async invalidateByPattern(pattern) {
+    return await this.cacheRepository.invalidate(pattern);
+  }
+  /**
+   * Completely empties the cache
+   *
+   * @returns Promise<void>
+   */
+  async clearCache() {
+    await this.cacheRepository.clear();
+  }
+  /**
+   * Retrieves detailed cache statistics
+   *
+   * @returns Promise<CacheStatistics>
+   */
+  async getCacheStatistics() {
+    return await this.cacheRepository.getStatistics();
+  }
+  /**
+   * Checks the health status of the cache
+   *
+   * @returns Promise<{ healthy: boolean; message: string; statistics: CacheStatistics }>
+   */
+  async healthCheck() {
+    try {
+      const stats = await this.cacheRepository.getStatistics();
+      const isHealthy = stats.size <= stats.maxSize * 0.9;
+      return {
+        healthy: isHealthy,
+        message: isHealthy ? "Cache is operating normally" : "Cache is near capacity limit",
+        statistics: stats
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        message: `Cache health check failed: ${error.message}`,
+        statistics: {
+          hits: 0,
+          misses: 0,
+          writes: 0,
+          size: 0,
+          maxSize: 0,
+          hitRate: 0,
+          usagePercentage: 0
+        }
+      };
+    }
+  }
+};
+
+// src/application/services/cacheService.service.ts
+var import_opticore_loader_translation = require("opticore-loader-translation");
+var import_opticore_logger = require("opticore-logger");
+var CacheService = class _CacheService {
+  cacheUseCase;
+  cacheRepository;
+  localLang;
+  configLogger;
+  /**
+   * Creates a CacheService instance
+   *
+   * @param cacheRepository - Cache repository (may be null if disabled)
+   * @param localLang
+   * @param configLogger
+   */
+  constructor(cacheRepository, localLang, configLogger) {
+    this.cacheRepository = cacheRepository;
+    this.localLang = localLang;
+    this.configLogger = configLogger;
+    this.cacheUseCase = cacheRepository ? new CacheManagementUseCase(cacheRepository) : null;
+  }
+  /**
+   * Retrieves a value or adds it if absent
+   *
+   * @param key - Input key
+   * @param fetcher - Function to retrieve the value if absent
+   * @param ttl - Specific time to live
+   * @returns Promise<T> - Cache value or fetch result
+   */
+  async getOrSet(key, fetcher, ttl) {
+    if (!this.cacheUseCase) {
+      return fetcher();
+    }
+    return this.cacheUseCase.getOrSet(key, fetcher, ttl);
+  }
+  /**
+   * Stores a value directly in the cache
+   *
+   * @param key - Input key
+   * @param value - Value to store
+   * @param ttl - Time to live
+   * @returns Promise<void>
+   */
+  async set(key, value, ttl) {
+    if (!this.cacheRepository) return;
+    await this.cacheRepository.set(key, value, ttl);
+  }
+  /**
+   * Retrieves a value from the cache
+   *
+   * @param key - Input key
+   * @returns Promise<T | null>
+   */
+  async get(key) {
+    if (!this.cacheRepository) return null;
+    return this.cacheRepository.get(key);
+  }
+  /**
+   * Removes an entry from the cache
+   *
+   * @param key - Entry key
+   * @returns Promise<void>
+   */
+  async delete(key) {
+    if (!this.cacheRepository) return;
+    await this.cacheRepository.delete(key);
+  }
+  /**
+   * Invalidates entries matching the pattern
+   *
+   * @param pattern - Pattern for selecting entries
+   * @returns Promise<number> - Number of invalidated entries
+   */
+  async invalidate(pattern) {
+    if (!this.cacheRepository) return 0;
+    return this.cacheRepository.invalidate(pattern);
+  }
+  /**
+   * Clear cache completely
+   *
+   * @returns Promise<void>
+   */
+  async clear() {
+    if (!this.cacheRepository) return;
+    await this.cacheRepository.clear();
+  }
+  /**
+   * Get cache stats
+   *
+   * @returns Promise<CacheStatistics>
+   */
+  async getStatistics() {
+    if (!this.cacheRepository) {
+      return {
+        hits: 0,
+        misses: 0,
+        writes: 0,
+        size: 0,
+        maxSize: 0,
+        hitRate: 0,
+        usagePercentage: 0
+      };
+    }
+    return this.cacheRepository.getStatistics();
+  }
+  /**
+   * Check the cache health status
+   *
+   * @returns Promise<{ healthy: boolean; message: string }>
+   */
+  async healthCheck() {
+    this.translatorConfig();
+    if (!this.cacheUseCase) {
+      return {
+        healthy: true,
+        message: (0, import_opticore_loader_translation.translate)({
+          key: "DISABLED_CACHE",
+          localeLanguage: this.localLang,
+          params: void 0
+        })
+      };
+    }
+    const health = await this.cacheUseCase.healthCheck();
+    return {
+      healthy: health.healthy,
+      message: health.message
+    };
+  }
+  /**
+   * Check if the cache is enabled
+   * @returns boolean
+   */
+  isEnabled() {
+    return this.cacheRepository !== null;
+  }
+  /**
+   * Retrieves all keys from the cache
+   *
+   * @returns Promise<string[]> - List of keys
+   */
+  async getKeys() {
+    if (!this.cacheRepository) return [];
+    return this.cacheRepository.keys();
+  }
+  /**
+   * Checks if a key exists in the cache
+   *
+   * @param key - Key to check
+   * @returns Promise<boolean>
+   */
+  async has(key) {
+    if (!this.cacheRepository) return false;
+    return this.cacheRepository.has(key);
+  }
+  /**
+   * Creates and configures a full cache service
+   *
+   * @param customConfig - Custom configuration (optional)
+   * @returns CacheService - Cache service configured
+   */
+  createCache(customConfig) {
+    const cacheRepository = CacheFactoryRepository.createCache(customConfig);
+    return new _CacheService(cacheRepository, this.localLang);
+  }
+  /**
+   *
+   * @private
+   */
+  translatorConfig() {
+    return (0, import_opticore_loader_translation.translationLoaderConfig)({
+      localLang: this.localLang,
+      locationTranslationFile: ["utils", "translations"],
+      packageName: "opticore-cache"
+    });
+  }
+  logger() {
+    return new import_opticore_logger.LoggerCore(this.configLogger);
+  }
+};
+
+// src/infrastructure/config/routeValidator.config.ts
+var RouteValidator = class {
+  /**
+   * Crée une instance de RouteValidator
+   *
+   * @param skipRoutes - Liste des routes à ignorer
+   * @param enableWildcards - Activer le support des wildcards
+   */
+  constructor(skipRoutes = [], enableWildcards = true) {
+    this.skipRoutes = skipRoutes;
+    this.enableWildcards = enableWildcards;
+    this.compileRoutePatterns();
+  }
+  routePatterns = [];
+  /**
+   * Compile les patterns de route en expressions régulières
+   *
+   * @private
+   */
+  compileRoutePatterns() {
+    this.routePatterns = this.skipRoutes.map((route) => {
+      const pattern = this.parseRoutePattern(route);
+      const regex = this.compileToRegex(pattern.path, this.enableWildcards);
+      return {
+        method: pattern.method,
+        path: pattern.path,
+        regexPattern: regex
+      };
+    });
+  }
+  /**
+   * Parse un pattern de route en méthode et chemin
+   *
+   * @param routePattern - Pattern à parser (format: "METHOD:path" ou "path")
+   * @returns {{ method?: string; path: string }}
+   */
+  parseRoutePattern(routePattern) {
+    const methodSeparatorIndex = routePattern.indexOf(":");
+    if (methodSeparatorIndex > 0) {
+      const methodPart = routePattern.substring(0, methodSeparatorIndex).toUpperCase();
+      const pathPart = routePattern.substring(methodSeparatorIndex + 1);
+      const httpMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"];
+      if (httpMethods.includes(methodPart)) {
+        return {
+          method: methodPart,
+          path: pathPart.trim()
+        };
+      }
+    }
+    return {
+      method: void 0,
+      // Toutes méthodes
+      path: routePattern.trim()
+    };
+  }
+  /**
+   * Compile un chemin en expression régulière
+   *
+   * @param path - Chemin à compiler
+   * @param enableWildcards - Activer le support des wildcards
+   * @returns RegExp
+   */
+  compileToRegex(path2, enableWildcards) {
+    if (!enableWildcards || !path2.includes("*")) {
+      return new RegExp(`^${this.escapeRegex(path2)}$`, "i");
+    }
+    let regexString = this.escapeRegex(path2).replace(/\\\*/g, ".*");
+    if (regexString.endsWith("/.*")) {
+      regexString = regexString.replace(/\/\.\*$/, "(\\/.*)?");
+    }
+    return new RegExp(`^${regexString}$`, "i");
+  }
+  /**
+   * Échappe les caractères spéciaux pour les expressions régulières
+   *
+   * @param string - Chaîne à échapper
+   * @returns string
+   */
+  escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Vérifie si une requête correspond à un pattern de route ignorée
+   *
+   * @param request - Requête Express à vérifier
+   * @returns boolean - True si la route doit être ignorée
+   */
+  shouldSkipRoute(request) {
+    const requestMethod = request.method.toUpperCase();
+    const requestPath = this.normalizePath(request.path);
+    for (const pattern of this.routePatterns) {
+      if (pattern.method && pattern.method !== requestMethod) {
+        continue;
+      }
+      if (pattern.regexPattern.test(requestPath)) {
+        return true;
+      }
+      const pathWithoutQuery = request?.originalUrl.split("?")[0];
+      if (pattern.regexPattern.test(this.normalizePath(pathWithoutQuery))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Normalise un chemin (supprime les slashes de fin)
+   *
+   * @param path - Chemin à normaliser
+   * @returns string - Chemin normalisé
+   */
+  normalizePath(path2) {
+    if (path2.length > 1 && path2.endsWith("/")) {
+      return path2.slice(0, -1);
+    }
+    return path2;
+  }
+  /**
+   * Récupère la liste des patterns compilés (pour debug)
+   *
+   * @returns RoutePattern[]
+   */
+  getCompiledPatterns() {
+    return [...this.routePatterns];
+  }
+};
+
+// src/infrastructure/middleware/cache.middleware.ts
+var CacheMiddleware = class {
+  routeValidator;
+  config;
+  /**
+   * Crée une instance de CacheMiddleware
+   */
+  constructor() {
+    const envLoader = EnvironmentLoader.getInstance();
+    this.config = envLoader.getConfig();
+    this.routeValidator = new RouteValidator(
+      this.config.skipRoutes,
+      this.config.enableWildcards
+    );
+  }
+  /**
+   * Crée un middleware Express configurable
+   * @param cacheRepository - Repository de cache à utiliser
+   * @param options - Options de configuration du middleware
+   * @returns Middleware Express
+   */
+  createMiddleware(cacheRepository, options = {}) {
+    return async (req, res, next) => {
+      if (!cacheRepository || !this.config.enabled || options.enabled === false) {
+        return next();
+      }
+      if (this.shouldSkipRequest(req, options)) {
+        if (this.config.debug) {
+          console.log(`[Cache] Skipping request: ${req.method} ${req.path}`);
+        }
+        return next();
+      }
+      if (req.method !== "GET") {
+        return next();
+      }
+      const keyGenerator = options.keyGenerator || this.defaultKeyGenerator;
+      const cacheKey = keyGenerator(req);
+      const ttl = options.timeToLive || this.config.defaultTTL;
+      try {
+        const cachedResponse = await cacheRepository.get(cacheKey);
+        if (cachedResponse !== null) {
+          this.addCacheHeaders(res, "HIT", cacheKey);
+          if (this.config.debug) {
+            console.log(`[Cache] Cache hit for key: ${cacheKey}`);
+          }
+          return res.json(cachedResponse);
+        }
+        if (this.config.debug) {
+          console.log(`[Cache] Cache miss for key: ${cacheKey}`);
+        }
+        const originalJson = res.json.bind(res);
+        let responseBody;
+        res.json = (body) => {
+          responseBody = body;
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            const bodyToCache = options.responseTransformer ? options.responseTransformer(body) : body;
+            cacheRepository.set(cacheKey, bodyToCache, ttl).then(() => {
+              if (this.config.debug) {
+                console.log(`[Cache] Successfully cached: ${cacheKey}`);
+              }
+            }).catch((error) => {
+              console.error("[Cache] Error caching response:", error);
+            });
+            this.addCacheHeaders(res, "MISS", cacheKey, ttl);
+          }
+          return originalJson(body);
+        };
+        next();
+      } catch (error) {
+        if (this.config.debug) {
+          console.error("[Cache] Middleware error:", error);
+        }
+        next();
+      }
+    };
+  }
+  /**
+   * Détermine si une requête doit être skipée
+   * @param req - Requête Express
+   * @param options - Options du middleware
+   * @returns boolean
+   * @private
+   */
+  shouldSkipRequest(req, options) {
+    if (options.shouldSkip && options.shouldSkip(req)) {
+      return true;
+    }
+    if (this.routeValidator.shouldSkipRoute(req)) {
+      return true;
+    }
+    const defaultSkipConditions = [
+      // Header spécifique pour bypasser le cache
+      req.headers["x-cache-bypass"] === "true",
+      req.headers["x-no-cache"] === "true",
+      // Certains chemins par défaut
+      req.path.includes("/api/admin/"),
+      req.path.includes("/api/debug/"),
+      req.path === "/health",
+      req.path === "/metrics",
+      // Basic Authentication
+      req.headers.authorization && !this.config.userAware
+    ];
+    return defaultSkipConditions.some((condition) => condition);
+  }
+  /**
+   * Générateur de clé par défaut
+   * @param req - Requête Express
+   * @returns string - Clé de cache
+   * @private
+   */
+  defaultKeyGenerator(req) {
+    const keyParts = [
+      this.config.namespace,
+      req.method,
+      this.normalizePath(req.path)
+    ];
+    if (this.config.userAware && req.user?.id) {
+      keyParts.push(`uid:${req.user.id}`);
+    }
+    if (Object.keys(req.query).length > 0) {
+      const queryString = Object.keys(req.query).sort().map((key) => `${key}=${req.query[key]}`).join("&");
+      keyParts.push(`qs:${queryString}`);
+    }
+    return keyParts.join(":");
+  }
+  /**
+   * Normalizes a path for the cache
+   *
+   * @param path - Path to be standardized
+   * @returns string
+   * @private
+   */
+  normalizePath(path2) {
+    if (path2.length > 1 && path2.endsWith("/")) {
+      return path2.slice(0, -1);
+    }
+    return path2;
+  }
+  /**
+   * Adds HTTP headers related to the cache
+   *
+   * @param res - Express Response
+   * @param status - Cache status (HIT/MISS)
+   * @param key - Cache key
+   * @param ttl - Lifespan (optional)
+   * @private
+   */
+  addCacheHeaders(res, status, key, ttl) {
+    res.setHeader("X-Cache-Status", status);
+    res.setHeader("X-Cache-Key", key);
+    if (ttl) {
+      res.setHeader("X-Cache-TTL", ttl.toString());
+      res.setHeader("X-Cache-Expires", new Date(Date.now() + ttl).toUTCString());
+    }
+    res.setHeader("X-Cache-Timestamp", (/* @__PURE__ */ new Date()).toISOString());
+  }
+  /**
+   * Creates middleware to display cache statistics
+   * @param cacheRepository - Cache repository
+   * @returns Middleware Express
+   */
+  createStatsMiddleware(cacheRepository) {
+    return async (req, res, next) => {
+      if (req.path === "/api/cache/stats" && req.method === "GET") {
+        try {
+          if (!cacheRepository) {
+            return res.json({
+              enabled: false,
+              message: "Cache is disabled",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          const stats = await cacheRepository.getStatistics();
+          const compiledPatterns = this.routeValidator.getCompiledPatterns();
+          res.json({
+            ...stats,
+            enabled: true,
+            configuration: {
+              ...this.config,
+              skipRoutes: compiledPatterns.map((pattern) => ({
+                method: pattern.method || "ALL",
+                path: pattern.path,
+                pattern: pattern.regexPattern.toString()
+              }))
+            },
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } catch (error) {
+          res.status(500).json({
+            error: "Failed to retrieve cache statistics",
+            details: error.message
+          });
+        }
+      } else {
+        next();
+      }
+    };
+  }
+  /**
+   * Create a middleware to clear the cache
+   *
+   * @param cacheRepository - Cache repository
+   * @returns Middleware Express
+   */
+  createClearMiddleware(cacheRepository) {
+    return async (req, res, next) => {
+      if (req.path === "/api/cache/clear" && req.method === "DELETE") {
+        try {
+          if (!cacheRepository) {
+            return res.json({
+              success: false,
+              message: "Cache is disabled",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          const pattern = req.query.pattern;
+          let message;
+          let clearedCount = 0;
+          if (pattern) {
+            clearedCount = await cacheRepository.invalidate(pattern);
+            message = `Cleared ${clearedCount} entries matching pattern: ${pattern}`;
+          } else {
+            await cacheRepository.clear();
+            message = "Cache cleared successfully";
+          }
+          res.json({
+            success: true,
+            message,
+            clearedCount,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } catch (error) {
+          res.status(500).json({
+            success: false,
+            error: "Failed to clear cache",
+            details: error.message
+          });
+        }
+      } else {
+        next();
+      }
+    };
+  }
+};
+
+// src/application/services/cacheMiddleware.service.ts
+var SCacheMiddleware = class {
+  /**
+   * Create and configure a complete caching service
+   *
+   * @param customConfig - Custom configuration (optional)
+   * @returns CacheService - Cache service configured
+   */
+  static cacheService(customConfig) {
+    const cacheRepository = CacheFactoryRepository.createCache(customConfig);
+    return new CacheService(cacheRepository, customConfig?.localLang);
+  }
+  /**
+   * Creates an Express middleware for automatic caching
+   *
+   * @param customConfig - Custom configuration (optional)
+   * @returns Express middleware configured
+   */
+  static cacheMiddleware(customConfig) {
+    const cacheRepository = CacheFactoryRepository.createCache(customConfig);
+    const middleware = new CacheMiddleware();
+    return middleware.createMiddleware(cacheRepository);
+  }
+  /**
+   * Creates a middleware for cache statistics
+   *
+   * @returns Middleware Express
+   */
+  static createStatsMiddleware() {
+    const cacheRepository = CacheFactoryRepository.createCache();
+    const middleware = new CacheMiddleware();
+    return middleware.createStatsMiddleware(cacheRepository);
+  }
+  /**
+   * Create a middleware to clear the cache
+   *
+   * @returns Middleware Express
+   */
+  static createClearMiddleware() {
+    const cacheRepository = CacheFactoryRepository.createCache();
+    const middleware = new CacheMiddleware();
+    return middleware.createClearMiddleware(cacheRepository);
+  }
+};
+
+// src/application/services/adaptedHttpCache.service.ts
+var AdaptedHttpCacheService = class {
+  constructor(cacheService, namespace = "http-cache") {
+    this.cacheService = cacheService;
+    this.namespace = namespace;
+  }
+  stats = { totalRequests: 0, cacheHits: 0, cacheMisses: 0 };
+  /**
+   *
+   * @param url
+   * @param options
+   * @param cacheOptions
+   */
+  async getWithCache(url, options, cacheOptions) {
+    this.stats.totalRequests++;
+    if (cacheOptions?.bypassCache) {
+      const response = await this.executeRequest("GET", url, options);
+      return this.mergeResponse(response);
+    }
+    const cacheKey = this.generateKey("GET", url, options, cacheOptions?.customKey);
+    const fullKey = `${this.namespace}:${cacheKey}`;
+    try {
+      const cachedResponse = await this.cacheService.getOrSet(
+        fullKey,
+        async () => {
+          this.stats.cacheMisses++;
+          return await this.executeRequest("GET", url, options);
+        },
+        cacheOptions?.timeToLive
+      );
+      this.stats.cacheHits++;
+      return this.mergeResponse(cachedResponse);
+    } catch (error) {
+      this.stats.cacheMisses++;
+      const response = await this.executeRequest("GET", url, options);
+      return this.mergeResponse(response);
+    }
+  }
+  /**
+   *
+   * @param url
+   * @param data
+   * @param options
+   * @param cacheResponse
+   * @param cacheOptions
+   */
+  async postWithCache(url, data, options, cacheResponse = false, cacheOptions) {
+    this.stats.totalRequests++;
+    const requestOptions = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers
+      },
+      body: JSON.stringify(data),
+      ...options
+    };
+    if (!cacheResponse || cacheOptions?.bypassCache) {
+      const response = await this.executeRequest("POST", url, requestOptions);
+      return this.mergeResponse(response);
+    }
+    const cacheKey = this.generateKey("POST", url, requestOptions, cacheOptions?.customKey);
+    const fullCacheKey = `${cacheOptions?.namespace || this.namespace}:${cacheKey}`;
+    try {
+      const cachedResponse = await this.cacheService.getOrSet(
+        fullCacheKey,
+        async () => {
+          this.stats.cacheMisses++;
+          return await this.executeRequest("POST", url, requestOptions);
+        },
+        cacheOptions?.timeToLive
+      );
+      return this.mergeResponse(cachedResponse);
+    } catch (error) {
+      console.error(`Cache error for POST ${url}:`, error.message);
+      this.stats.cacheMisses++;
+      const response = await this.executeRequest("POST", url, requestOptions);
+      return this.mergeResponse(response);
+    }
+  }
+  /**
+   *
+   * @param method
+   * @param url
+   * @param options
+   * @private
+   */
+  async executeRequest(method, url, options) {
+    const response = await fetch(url, { method, ...options });
+    const data = await response.json();
+    return {
+      data,
+      metadata: {
+        status: response.status,
+        cached: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        url,
+        method
+      }
+    };
+  }
+  /**
+   *
+   * @param response
+   * @private
+   */
+  mergeResponse(response) {
+    const result = { ...response.data, _metadata: response.metadata };
+    return result;
+  }
+  /**
+   *
+   * @param method
+   * @param url
+   * @param options
+   * @param customKey
+   * @private
+   */
+  generateKey(method, url, options, customKey) {
+    if (customKey) return customKey;
+    const keyParts = [
+      method,
+      url,
+      JSON.stringify(options?.headers || {}),
+      options?.body ? JSON.stringify(options.body) : ""
+    ];
+    return Buffer.from(keyParts.join("|")).toString("base64");
+  }
+  /**
+   *
+   * @param urlOrPattern
+   */
+  async invalidateCache(urlOrPattern) {
+    try {
+      console.log(`Invalidating cache for pattern: ${urlOrPattern}`);
+      const encodedPattern = Buffer.from(urlOrPattern).toString("base64").slice(0, 20);
+      const searchPattern = `*${encodedPattern}*`;
+      const invalidatedCount = await this.cacheService.invalidate(searchPattern);
+      console.log(`Invalidated ${invalidatedCount} entries for pattern: ${urlOrPattern}`);
+      return invalidatedCount;
+    } catch (error) {
+      console.error(`Error invalidating cache for ${urlOrPattern}:`, error.message);
+      try {
+        if (urlOrPattern.startsWith(this.namespace + ":")) {
+          await this.cacheService.delete(urlOrPattern);
+          return 1;
+        }
+      } catch (fallbackError) {
+      }
+      return 0;
+    }
+  }
+  /**
+   *
+   */
+  async clearHttpCache() {
+    try {
+      console.log("Clearing HTTP cache...");
+      if (typeof this.cacheService.clear === "function") {
+        await this.cacheService.clear();
+      } else if (typeof this.cacheService.keys === "function") {
+        const allKeys = await this.cacheService.getKeys();
+        const httpKeys = allKeys.filter((key) => key.startsWith(this.namespace + ":"));
+        for (const key of httpKeys) {
+          await this.cacheService.delete(key);
+        }
+        console.log(`Cleared ${httpKeys.length} HTTP cache entries`);
+      }
+      this.stats = { totalRequests: 0, cacheHits: 0, cacheMisses: 0 };
+      console.log("HTTP cache cleared successfully");
+    } catch (error) {
+      console.error("Error clearing HTTP cache:", error.message);
+      throw new Error(`Failed to clear HTTP cache: ${error.message}`);
+    }
+  }
+  async getStats() {
+    try {
+      const cacheStats = await this.cacheService.getStatistics();
+      const cachedKeys = await this.cacheService.getKeys();
+      const httpKeys = cachedKeys.filter((key) => key.startsWith(this.namespace + ":"));
+      const totalRequests = this.stats.totalRequests;
+      const hitRate = totalRequests > 0 ? this.stats.cacheHits / totalRequests * 100 : 0;
+      return {
+        totalRequests,
+        cacheHits: this.stats.cacheHits,
+        cacheMisses: this.stats.cacheMisses,
+        cacheSize: httpKeys.length,
+        hitRate: parseFloat(hitRate.toFixed(2)),
+        cachedUrls: httpKeys,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        enabled: this.isEnabled()
+      };
+    } catch (error) {
+      console.error("Error getting cache stats:", error.message);
+      return this.getDefaultStats();
+    }
+  }
+  getDefaultStats() {
+    return {
+      totalRequests: this.stats.totalRequests,
+      cacheHits: this.stats.cacheHits,
+      cacheMisses: this.stats.cacheMisses,
+      cacheSize: 0,
+      hitRate: 0,
+      cachedUrls: [],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      enabled: false
+    };
+  }
+  isEnabled() {
+    try {
+      if (this.cacheService.isEnabled && typeof this.cacheService.isEnabled === "function") {
+        return this.cacheService.isEnabled();
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/application/services/fetch.client.service.ts
+var FetchHttpClient = class {
+  async request(url, options = {}) {
+    const { method = "GET", headers = {}, body, timeout = 3e4 } = options;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const requestBody = body ? typeof body === "string" ? body : JSON.stringify(body) : void 0;
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: requestBody,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const text = await response.text();
+      console.log(`[FetchClient] ${method} ${url} -> status ${response.status}, body length ${text.length}`);
+      const contentType = response.headers.get("content-type") || "";
+      let data;
+      if (contentType.includes("application/json")) {
+        try {
+          data = JSON.parse(text);
+        } catch (e) {
+          console.warn(`[FetchClient] Invalid JSON received, treating as text`);
+          data = text;
+        }
+      } else {
+        data = text;
+      }
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        data
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+};
+
+// src/application/services/httpCacheClient.service.ts
+var HttpCacheClient = class {
+  cacheService;
+  httpClient;
+  stats = { totalRequests: 0, cacheHits: 0, cacheMisses: 0 };
+  defaultOptions;
+  constructor(httpClient, cacheService, options) {
+    this.httpClient = httpClient || new FetchHttpClient();
+    this.defaultOptions = {
+      baseURL: options?.baseURL,
+      headers: options?.headers,
+      timeout: options?.timeout || 3e4
+    };
+    if (cacheService) {
+      this.cacheService = cacheService;
+    } else {
+      const cacheConfig = options?.cacheConfig || {};
+      const repository = CacheFactoryRepository.createCache({
+        namespace: cacheConfig.namespace || "http-cache",
+        maxSize: cacheConfig.maxSize || 1e4,
+        defaultTTL: cacheConfig.defaultTTL || 3e5,
+        storageType: cacheConfig.storageType || "disk",
+        CACHE_DISK_DIR: cacheConfig.diskDir || "./storage/cache/http",
+        enabled: true
+      });
+      this.cacheService = new CacheService(repository, "en");
+    }
+  }
+  async getWithCache(url, options, cacheOptions) {
+    this.stats.totalRequests++;
+    const fullUrl = this.buildUrl(url);
+    const cacheKey = this.generateCacheKey("GET", fullUrl, options, cacheOptions?.customKey);
+    const ttl = cacheOptions?.timeToLive;
+    try {
+      const cached = await this.cacheService.get(cacheKey);
+      if (cached) {
+        this.stats.cacheHits++;
+        return {
+          ...cached.data,
+          _metadata: {
+            ...cached.metadata,
+            cached: true,
+            cacheHit: true,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        };
+      }
+      this.stats.cacheMisses++;
+      const response = await this.executeRequest("GET", fullUrl, options);
+      await this.cacheService.set(cacheKey, response, ttl);
+      return {
+        ...response.data,
+        _metadata: {
+          ...response.metadata,
+          cached: false,
+          cacheHit: false,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    } catch (error) {
+      this.stats.cacheMisses++;
+      const response = await this.executeRequest("GET", fullUrl, options);
+      return {
+        ...response.data,
+        _metadata: {
+          ...response.metadata,
+          cached: false,
+          cacheHit: false,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    }
+  }
+  async postWithCache(url, data, options, cacheResponse = false, cacheOptions) {
+    this.stats.totalRequests++;
+    const fullUrl = this.buildUrl(url);
+    const requestOptions = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.defaultOptions.headers,
+        ...options?.headers
+      },
+      body: data ? JSON.stringify(data) : void 0,
+      ...options
+    };
+    if (!cacheResponse) {
+      const response = await this.executeRequest("POST", fullUrl, requestOptions);
+      return {
+        ...response.data,
+        _metadata: response.metadata
+      };
+    }
+    const cacheKey = this.generateCacheKey("POST", fullUrl, requestOptions, cacheOptions?.customKey);
+    const ttl = cacheOptions?.timeToLive;
+    try {
+      const cached = await this.cacheService.get(cacheKey);
+      if (cached) {
+        this.stats.cacheHits++;
+        return {
+          ...cached.data,
+          _metadata: cached.metadata
+        };
+      }
+      this.stats.cacheMisses++;
+      const response = await this.executeRequest("POST", fullUrl, requestOptions);
+      await this.cacheService.set(cacheKey, response, ttl);
+      return {
+        ...response.data,
+        _metadata: response.metadata
+      };
+    } catch (error) {
+      this.stats.cacheMisses++;
+      const response = await this.executeRequest("POST", fullUrl, requestOptions);
+      return {
+        ...response.data,
+        _metadata: response.metadata
+      };
+    }
+  }
+  async executeRequest(method, url, options) {
+    const startTime = Date.now();
+    const response = await this.httpClient.request(url, {
+      method,
+      headers: options?.headers,
+      body: options?.body,
+      timeout: this.defaultOptions.timeout
+    });
+    const responseTime = Date.now() - startTime;
+    if (response.status < 200 || response.status >= 300) {
+      const errorMessage = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
+      throw new Error(`HTTP ${response.status}: ${errorMessage}`);
+    }
+    let result = response.data;
+    if (typeof result === "string") {
+      try {
+        result = JSON.parse(result);
+      } catch {
+        console.warn(`[HttpCacheClient] Response is not JSON: ${String(result).substring(0, 100)}`);
+      }
+    }
+    return {
+      status: response.status,
+      statusText: response.statusText || "OK",
+      headers: response.headers || {},
+      data: result,
+      metadata: {
+        cached: true,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        url,
+        method,
+        responseTime
+      }
+    };
+  }
+  buildUrl(url) {
+    if (url.startsWith("http://") || url.startsWith("https://")) return url;
+    return this.defaultOptions.baseURL ? this.defaultOptions.baseURL + url : url;
+  }
+  generateCacheKey(method, url, options, customKey) {
+    if (customKey) return `http:${customKey}`;
+    const keyParts = [
+      method,
+      url,
+      JSON.stringify(options?.headers || {}),
+      options?.body ? JSON.stringify(options.body) : ""
+    ];
+    return `http:${this.hashString(keyParts.join("|"))}`;
+  }
+  hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36);
+  }
+  async invalidateCache(urlOrPattern) {
+    return this.cacheService.invalidate(`*${urlOrPattern}*`);
+  }
+  async clearHttpCache() {
+    await this.cacheService.clear();
+    this.stats = { totalRequests: 0, cacheHits: 0, cacheMisses: 0 };
+  }
+  async getStats() {
+    const cacheStats = await this.cacheService.getStatistics();
+    const keys = await this.cacheService.getKeys();
+    const httpKeys = keys.filter((k) => k.startsWith("http:"));
+    const hitRate = this.stats.totalRequests > 0 ? this.stats.cacheHits / this.stats.totalRequests * 100 : 0;
+    return {
+      totalRequests: this.stats.totalRequests,
+      cacheHits: this.stats.cacheHits,
+      cacheMisses: this.stats.cacheMisses,
+      cacheSize: httpKeys.length,
+      hitRate: parseFloat(hitRate.toFixed(2)),
+      cachedUrls: httpKeys,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      enabled: this.cacheService.isEnabled()
+    };
+  }
+  isEnabled() {
+    return this.cacheService.isEnabled();
+  }
+};
+
+// src/application/services/node-http.client.service.ts
+var http = __toESM(require("http"), 1);
+var https = __toESM(require("https"), 1);
+var import_url = require("url");
+var NodeHttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(url, options = {}) {
+    const { method = "GET", headers = {}, body, timeout = 3e4 } = options;
+    const startTime = Date.now();
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new import_url.URL(url);
+      const isHttps = parsedUrl.protocol === "https:";
+      const client = isHttps ? https : http;
+      const requestOptions = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port || (isHttps ? 443 : 80),
+        path: parsedUrl.pathname + parsedUrl.search,
+        method,
+        headers,
+        timeout
+      };
+      const req = client.request(requestOptions, (res) => {
+        let rawData = "";
+        res.on("data", (chunk) => {
+          rawData += chunk;
+        });
+        res.on("end", () => {
+          const responseTime = Date.now() - startTime;
+          const contentType = res.headers["content-type"] || "";
+          let data;
+          try {
+            if (contentType.includes("application/json")) {
+              data = JSON.parse(rawData);
+            } else {
+              data = rawData;
+            }
+          } catch {
+            data = rawData;
+          }
+          resolve({
+            status: res.statusCode || 200,
+            statusText: res.statusMessage || "OK",
+            headers: res.headers,
+            data,
+            metadata: {
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              url,
+              method,
+              responseTime,
+              cached: false
+            }
+          });
+        });
+      });
+      req.on("error", (err) => {
+        reject(err);
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error(`Request timeout after ${timeout}ms`));
+      });
+      if (body) {
+        const bodyString = typeof body === "string" ? body : JSON.stringify(body);
+        req.write(bodyString);
+      }
+      req.end();
+    });
+  }
+};
+
+// src/application/services/axios.client.service.ts
+var axios;
+var AxiosHttpClient = class {
+  axiosInstance;
+  constructor(config) {
+    try {
+      axios = require("axios");
+    } catch (e) {
+      throw new Error("Axios is not installed. Please run: npm install axios");
+    }
+    this.axiosInstance = axios.create(config);
+  }
+  async request(url, options = {}) {
+    const { method = "GET", headers = {}, body, timeout = 3e4 } = options;
+    const startTime = Date.now();
+    try {
+      const response = await this.axiosInstance({
+        method: method.toLowerCase(),
+        url,
+        headers,
+        data: body,
+        timeout,
+        validateStatus: () => true
+      });
+      const responseTime = Date.now() - startTime;
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        data: response.data,
+        metadata: {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          url,
+          method,
+          responseTime,
+          cached: false
+        }
+      };
+    } catch (error) {
+      if (error.response) {
+        const responseTime = Date.now() - startTime;
+        return {
+          status: error.response.status,
+          statusText: error.response.statusText,
+          headers: error.response.headers,
+          data: error.response.data,
+          metadata: {
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            url,
+            method,
+            responseTime,
+            cached: false
+          }
+        };
+      }
+      throw error;
+    }
+  }
+};
+
+// src/application/services/curl.client.service.ts
+var import_child_process = require("child_process");
+var import_util2 = require("util");
+var execAsync = (0, import_util2.promisify)(import_child_process.exec);
+var CurlHttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(url, options = {}) {
+    const { method = "GET", headers = {}, timeout = 3e4, body } = options;
+    const startTime = Date.now();
+    const curlCmd = this.buildCommand(url, method, headers, timeout, body);
+    try {
+      const { stdout, stderr } = await execAsync(curlCmd, { timeout });
+      if (stderr) {
+        console.warn(`[CurlClient] stderr: ${stderr}`);
+      }
+      const responseTime = Date.now() - startTime;
+      let data;
+      try {
+        data = JSON.parse(stdout);
+      } catch {
+        data = stdout;
+      }
+      return {
+        status: 200,
+        // approximation
+        statusText: "OK",
+        headers: {},
+        data,
+        metadata: {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          url,
+          method,
+          responseTime,
+          cached: false
+        }
+      };
+    } catch (error) {
+      throw new Error(`Curl execution failed: ${error.message}`);
+    }
+  }
+  buildCommand(url, method, headers, timeout, body) {
+    const parts = [];
+    if (this.config?.curlPath) {
+      parts.push(this.config.curlPath);
+    } else {
+      parts.push("curl");
+    }
+    parts.push("-s", "-S");
+    parts.push("--max-time", Math.ceil(timeout / 1e3).toString());
+    if (method !== "GET") {
+      parts.push("-X", method);
+    }
+    for (const [key, value] of Object.entries(headers)) {
+      parts.push("-H", `"${key}: ${value}"`);
+    }
+    if (body) {
+      const bodyString = typeof body === "string" ? body : JSON.stringify(body);
+      parts.push("--data-binary", `"${bodyString}"`);
+    }
+    parts.push(url);
+    if (this.config?.additionalArgs) {
+      parts.push(...this.config.additionalArgs);
+    }
+    return parts.join(" ");
+  }
+};
+
+// src/application/services/httpCacheFactory.service.ts
+var HttpCacheFactory = class {
+  static instances = /* @__PURE__ */ new Map();
+  static create(appName = "default", config) {
+    const instanceKey = `${appName}:${config?.clientType || "fetch"}`;
+    if (!this.instances.has(instanceKey)) {
+      let httpClient;
+      switch (config?.clientType) {
+        case "node-http":
+          httpClient = new NodeHttpClient(config?.clientOptions);
+          break;
+        case "axios":
+          httpClient = new AxiosHttpClient(config?.clientOptions);
+          break;
+        case "curl":
+          httpClient = new CurlHttpClient(config?.clientOptions);
+          break;
+        case "fetch":
+        default:
+          httpClient = new FetchHttpClient();
+          break;
+      }
+      const cacheConfig = {
+        namespace: config?.namespace || `http-cache-${appName}`,
+        maxSize: config?.maxSize || 1e4,
+        defaultTTL: config?.defaultTTL || 3e5,
+        storageType: config?.storageType || "disk",
+        diskDir: config?.diskDir || `./storage/cache/${appName}`
+      };
+      const instance = new HttpCacheClient(httpClient, void 0, {
+        cacheConfig,
+        timeout: config?.clientOptions?.timeout,
+        headers: config?.clientOptions?.headers,
+        baseURL: config?.clientOptions?.baseURL
+      });
+      this.instances.set(instanceKey, instance);
+    }
+    return this.instances.get(instanceKey);
+  }
+  static createFromExistingCache(cacheService, namespace = "http-cache") {
+    return new AdaptedHttpCacheService(cacheService, namespace);
+  }
+  static destroy(appName = "default", clientType) {
+    const key = `${appName}:${clientType || "fetch"}`;
+    this.instances.delete(key);
+  }
+};
+
+// src/index.ts
+import_dotenv.default.config();
+var index_default = {
+  SCacheMiddleware,
+  CacheService,
+  CacheMiddleware,
+  CacheFactoryRepository,
+  RouteValidator,
+  EnvironmentLoader,
+  HttpCacheFactory
+};