REFONTE: Système RSS V2 - Réécriture complète

Problèmes résolus:
- Articles non mis à jour (toujours 12 nov au lieu de 14 nov)
- Détection de doublons défaillante
- Cache trop agressif bloquant les nouveaux articles
- Logique complexe et difficile à déboguer

Architecture V2 (simple et robuste):

**services/rss-scheduler-v2.js**
- Détection doublons SIMPLE: uniquement par lien
- Pas de double vérification titre+date (trop complexe)
- Nettoyage automatique (garde les 100 derniers)
- Logs clairs pour chaque étape
- Fetch séquentiel pour éviter les races
- Timeout robuste (15s par flux)

**routes/rss.routes-v2.js**
- Suppression du cache de 30s
- Requêtes SQL directes simples
- Pas de logique de filtre temporel compliquée
- Endpoint /refresh déclenche un fetch immédiat
- Logs cohérents

**Scripts utilitaires**
- reset-rss.js: Nettoie complètement la DB RSS
- migrate-to-rss-v2.js: Migre de V1 à V2
- Plus tous les scripts de debug existants

Backups:
- rss-scheduler.js.backup (ancien système)
- rss.routes.js.backup (ancien système)

Migration:
1. node scripts/reset-rss.js (optionnel, nettoie la DB)
2. Redémarrer le serveur
3. Ajouter les flux RSS via l'interface
4. Les articles seront récupérés toutes les 2 minutes

Résultat attendu:
- Les nouveaux articles apparaissent dans les 2 minutes
- Pas de doublons même avec liens changeants
- Affichage du plus récent au plus ancien
- Système simple, maintenable et debuggable

services/rss-scheduler-v2.js

@@ -0,0 +1,233 @@
+// Service RSS NOUVEAU - Architecture simple et robuste
+const Parser = require('rss-parser');
+const { getAll, getOne, runQuery } = require('../config/database');
+const logger = require('../config/logger');
+
+const parser = new Parser({
+  timeout: 10000,
+  headers: {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+  }
+});
+
+let isRunning = false;
+
+// Configuration
+const MAX_ARTICLES_PER_FEED = 100; // Garder max 100 articles par flux
+const FETCH_INTERVAL = 2 * 60 * 1000; // 2 minutes
+const STARTUP_DELAY = 5000; // 5 secondes
+
+/**
+ * Récupérer et stocker les articles d'un flux
+ */
+async function fetchSingleFeed(feed) {
+  const startTime = Date.now();
+  let newArticlesCount = 0;
+
+  try {
+    logger.info(`⏳ Récupération: ${feed.title || feed.url}`);
+
+    // Parser le flux avec timeout
+    const parsedFeed = await Promise.race([
+      parser.parseURL(feed.url),
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error('Timeout après 15s')), 15000)
+      )
+    ]);
+
+    // Mettre à jour les infos du flux
+    await runQuery(
+      'UPDATE rss_feeds SET title = ?, description = ?, last_fetched_at = CURRENT_TIMESTAMP WHERE id = ?',
+      [parsedFeed.title || feed.url, parsedFeed.description || '', feed.id]
+    );
+
+    // Traiter les articles (prendre les 50 premiers)
+    const items = parsedFeed.items.slice(0, 50);
+    logger.debug(`  ${items.length} articles dans le flux`);
+
+    for (const item of items) {
+      try {
+        // Validation minimale
+        if (!item.title || !item.link) {
+          logger.debug(`  ⚠️  Article ignoré: pas de titre ou lien`);
+          continue;
+        }
+
+        // Normaliser la date
+        let pubDate;
+        try {
+          const dateStr = item.pubDate || item.isoDate;
+          pubDate = dateStr ? new Date(dateStr).toISOString() : new Date().toISOString();
+
+          // Vérifier que la date est valide
+          if (isNaN(new Date(pubDate).getTime())) {
+            pubDate = new Date().toISOString();
+          }
+        } catch (e) {
+          pubDate = new Date().toISOString();
+        }
+
+        // Vérifier si l'article existe UNIQUEMENT par lien
+        // Simple et fiable
+        const existing = await getOne(
+          'SELECT id FROM rss_articles WHERE link = ?',
+          [item.link]
+        );
+
+        if (!existing) {
+          // Nouvel article - l'ajouter
+          await runQuery(
+            `INSERT INTO rss_articles (feed_id, title, link, description, pub_date, content)
+             VALUES (?, ?, ?, ?, ?, ?)`,
+            [
+              feed.id,
+              item.title.trim(),
+              item.link,
+              item.contentSnippet || item.description || '',
+              pubDate,
+              item.content || item['content:encoded'] || ''
+            ]
+          );
+
+          newArticlesCount++;
+          logger.debug(`  ✓ Ajouté: ${item.title.substring(0, 60)}...`);
+        }
+
+      } catch (articleError) {
+        // Log mais continue
+        if (articleError.message.includes('UNIQUE')) {
+          logger.debug(`  - Doublon: ${item.title?.substring(0, 60)}...`);
+        } else {
+          logger.warn(`  ⚠️  Erreur article: ${articleError.message}`);
+        }
+      }
+    }
+
+    // Nettoyer les vieux articles (garder les N derniers)
+    const articlesCount = await getOne(
+      'SELECT COUNT(*) as count FROM rss_articles WHERE feed_id = ?',
+      [feed.id]
+    );
+
+    if (articlesCount.count > MAX_ARTICLES_PER_FEED) {
+      const toDelete = articlesCount.count - MAX_ARTICLES_PER_FEED;
+      await runQuery(`
+        DELETE FROM rss_articles
+        WHERE id IN (
+          SELECT id FROM rss_articles
+          WHERE feed_id = ?
+          ORDER BY pub_date ASC
+          LIMIT ?
+        )
+      `, [feed.id, toDelete]);
+      logger.debug(`  🗑️  ${toDelete} anciens articles supprimés`);
+    }
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    logger.info(`✅ ${feed.title}: ${newArticlesCount} nouveaux (${duration}s)`);
+
+    return { success: true, newArticles: newArticlesCount };
+
+  } catch (error) {
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    logger.error(`❌ ${feed.title || feed.url}: ${error.message} (${duration}s)`);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Récupérer tous les flux activés
+ */
+async function fetchAllFeeds() {
+  if (isRunning) {
+    logger.debug('⏭️  Fetch déjà en cours, skip');
+    return { skipped: true };
+  }
+
+  isRunning = true;
+  const globalStart = Date.now();
+
+  try {
+    logger.info('🔄 === Début mise à jour RSS ===');
+
+    // Récupérer tous les flux activés
+    const feeds = await getAll('SELECT * FROM rss_feeds WHERE enabled = 1');
+
+    if (!feeds || feeds.length === 0) {
+      logger.info('⚠️  Aucun flux RSS activé');
+      return { feeds: 0, newArticles: 0 };
+    }
+
+    logger.info(`📰 ${feeds.length} flux à traiter`);
+
+    let totalNew = 0;
+    let successCount = 0;
+    let errorCount = 0;
+
+    // Traiter chaque flux séquentiellement
+    for (const feed of feeds) {
+      const result = await fetchSingleFeed(feed);
+
+      if (result.success) {
+        successCount++;
+        totalNew += result.newArticles;
+      } else {
+        errorCount++;
+      }
+    }
+
+    const totalDuration = ((Date.now() - globalStart) / 1000).toFixed(2);
+    logger.info(`✅ === Fin: ${totalNew} nouveaux articles (${successCount} OK, ${errorCount} erreurs, ${totalDuration}s) ===`);
+
+    return {
+      feeds: feeds.length,
+      newArticles: totalNew,
+      success: successCount,
+      errors: errorCount
+    };
+
+  } catch (error) {
+    logger.error('❌ Erreur globale fetch RSS:', error);
+    return { error: error.message };
+  } finally {
+    isRunning = false;
+  }
+}
+
+/**
+ * Démarrer le scheduler
+ */
+function startScheduler() {
+  logger.info('📰 === RSS Scheduler V2 démarré ===');
+  logger.info(`Configuration: fetch toutes les ${FETCH_INTERVAL / 60000} minutes`);
+  logger.info(`Max articles par flux: ${MAX_ARTICLES_PER_FEED}`);
+
+  // Premier fetch après le démarrage
+  setTimeout(() => {
+    logger.info('🚀 Premier fetch RSS...');
+    fetchAllFeeds().catch(err => {
+      logger.error('Erreur premier fetch:', err);
+    });
+  }, STARTUP_DELAY);
+
+  // Fetch régulier
+  setInterval(() => {
+    fetchAllFeeds().catch(err => {
+      logger.error('Erreur fetch périodique:', err);
+    });
+  }, FETCH_INTERVAL);
+}
+
+/**
+ * Fetch manuel (API)
+ */
+async function manualFetch() {
+  logger.info('🔄 Fetch manuel déclenché');
+  return await fetchAllFeeds();
+}
+
+module.exports = {
+  startScheduler,
+  manualFetch,
+  fetchAllFeeds
+};

services/rss-scheduler.js

@@ -1,4 +1,4 @@
-// Service de mise à jour automatique des flux RSS
+// Service RSS NOUVEAU - Architecture simple et robuste
 const Parser = require('rss-parser');
 const { getAll, getOne, runQuery } = require('../config/database');
 const logger = require('../config/logger');
@@ -6,214 +6,228 @@ const logger = require('../config/logger');
 const parser = new Parser({
   timeout: 10000,
   headers: {
-    'User-Agent': 'NoteFlow RSS Reader'
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
   }
 });
 
 let isRunning = false;
 
+// Configuration
+const MAX_ARTICLES_PER_FEED = 100; // Garder max 100 articles par flux
+const FETCH_INTERVAL = 2 * 60 * 1000; // 2 minutes
+const STARTUP_DELAY = 5000; // 5 secondes
+
 /**
- * Initialiser des flux RSS par défaut
+ * Récupérer et stocker les articles d'un flux
  */
-async function initializeDefaultFeeds() {
+async function fetchSingleFeed(feed) {
+  const startTime = Date.now();
+  let newArticlesCount = 0;
+
   try {
-    const existingFeeds = await getAll('SELECT COUNT(*) as count FROM rss_feeds');
+    logger.info(`⏳ Récupération: ${feed.title || feed.url}`);
 
-    if (existingFeeds[0].count === 0) {
-      logger.info('🔧 Aucun flux RSS trouvé, ajout de flux par défaut...');
+    // Parser le flux avec timeout
+    const parsedFeed = await Promise.race([
+      parser.parseURL(feed.url),
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error('Timeout après 15s')), 15000)
+      )
+    ]);
 
-      const defaultFeeds = [
-        'https://www.lemonde.fr/rss/une.xml',
-        'https://feeds.bbci.co.uk/news/world/rss.xml',
-        'https://www.lefigaro.fr/rss/figaro_actualites.xml'
-      ];
+    // Mettre à jour les infos du flux
+    await runQuery(
+      'UPDATE rss_feeds SET title = ?, description = ?, last_fetched_at = CURRENT_TIMESTAMP WHERE id = ?',
+      [parsedFeed.title || feed.url, parsedFeed.description || '', feed.id]
+    );
 
-      for (const url of defaultFeeds) {
+    // Traiter les articles (prendre les 50 premiers)
+    const items = parsedFeed.items.slice(0, 50);
+    logger.debug(`  ${items.length} articles dans le flux`);
+
+    for (const item of items) {
+      try {
+        // Validation minimale
+        if (!item.title || !item.link) {
+          logger.debug(`  ⚠️  Article ignoré: pas de titre ou lien`);
+          continue;
+        }
+
+        // Normaliser la date
+        let pubDate;
         try {
-          const feed = await parser.parseURL(url);
+          const dateStr = item.pubDate || item.isoDate;
+          pubDate = dateStr ? new Date(dateStr).toISOString() : new Date().toISOString();
+
+          // Vérifier que la date est valide
+          if (isNaN(new Date(pubDate).getTime())) {
+            pubDate = new Date().toISOString();
+          }
+        } catch (e) {
+          pubDate = new Date().toISOString();
+        }
+
+        // Vérifier si l'article existe UNIQUEMENT par lien
+        // Simple et fiable
+        const existing = await getOne(
+          'SELECT id FROM rss_articles WHERE link = ?',
+          [item.link]
+        );
+
+        if (!existing) {
+          // Nouvel article - l'ajouter
           await runQuery(
-            'INSERT INTO rss_feeds (url, title, description, enabled) VALUES (?, ?, ?, 1)',
-            [url, feed.title || url, feed.description || '']
+            `INSERT INTO rss_articles (feed_id, title, link, description, pub_date, content)
+             VALUES (?, ?, ?, ?, ?, ?)`,
+            [
+              feed.id,
+              item.title.trim(),
+              item.link,
+              item.contentSnippet || item.description || '',
+              pubDate,
+              item.content || item['content:encoded'] || ''
+            ]
           );
-          logger.info(`✓ Flux ajouté: ${feed.title || url}`);
-        } catch (error) {
-          logger.warn(`⚠️  Impossible d'ajouter ${url}: ${error.message}`);
+
+          newArticlesCount++;
+          logger.debug(`  ✓ Ajouté: ${item.title.substring(0, 60)}...`);
+        }
+
+      } catch (articleError) {
+        // Log mais continue
+        if (articleError.message.includes('UNIQUE')) {
+          logger.debug(`  - Doublon: ${item.title?.substring(0, 60)}...`);
+        } else {
+          logger.warn(`  ⚠️  Erreur article: ${articleError.message}`);
         }
       }
-
-      logger.info('✓ Flux RSS par défaut initialisés');
-      return true;
     }
 
-    return false;
+    // Nettoyer les vieux articles (garder les N derniers)
+    const articlesCount = await getOne(
+      'SELECT COUNT(*) as count FROM rss_articles WHERE feed_id = ?',
+      [feed.id]
+    );
+
+    if (articlesCount.count > MAX_ARTICLES_PER_FEED) {
+      const toDelete = articlesCount.count - MAX_ARTICLES_PER_FEED;
+      await runQuery(`
+        DELETE FROM rss_articles
+        WHERE id IN (
+          SELECT id FROM rss_articles
+          WHERE feed_id = ?
+          ORDER BY pub_date ASC
+          LIMIT ?
+        )
+      `, [feed.id, toDelete]);
+      logger.debug(`  🗑️  ${toDelete} anciens articles supprimés`);
+    }
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    logger.info(`✅ ${feed.title}: ${newArticlesCount} nouveaux (${duration}s)`);
+
+    return { success: true, newArticles: newArticlesCount };
+
   } catch (error) {
-    logger.error('Erreur lors de l\'initialisation des flux par défaut:', error);
-    return false;
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    logger.error(`❌ ${feed.title || feed.url}: ${error.message} (${duration}s)`);
+    return { success: false, error: error.message };
   }
 }
 
 /**
- * Récupérer et mettre à jour tous les flux RSS activés
+ * Récupérer tous les flux activés
  */
 async function fetchAllFeeds() {
   if (isRunning) {
-    logger.info('Fetch RSS déjà en cours, skip...');
-    return;
+    logger.debug('⏭️  Fetch déjà en cours, skip');
+    return { skipped: true };
   }
 
   isRunning = true;
-  const startTime = Date.now();
+  const globalStart = Date.now();
 
   try {
-    logger.info('🔄 Début de la mise à jour des flux RSS...');
+    logger.info('🔄 === Début mise à jour RSS ===');
 
     // Récupérer tous les flux activés
     const feeds = await getAll('SELECT * FROM rss_feeds WHERE enabled = 1');
 
     if (!feeds || feeds.length === 0) {
-      logger.info('⚠️  Aucun flux RSS activé, initialisation...');
-      const initialized = await initializeDefaultFeeds();
-      if (initialized) {
-        // Réessayer avec les nouveaux flux
-        isRunning = false;
-        return await fetchAllFeeds();
-      }
-      isRunning = false;
-      return;
+      logger.info('⚠️  Aucun flux RSS activé');
+      return { feeds: 0, newArticles: 0 };
     }
 
-    logger.info(`📰 Mise à jour de ${feeds.length} flux RSS...`);
+    logger.info(`📰 ${feeds.length} flux à traiter`);
 
-    let totalArticles = 0;
-    let totalErrors = 0;
+    let totalNew = 0;
+    let successCount = 0;
+    let errorCount = 0;
 
-    // Traiter chaque flux
+    // Traiter chaque flux séquentiellement
     for (const feed of feeds) {
-      try {
-        logger.info(`⏳ Fetch: ${feed.url}`);
+      const result = await fetchSingleFeed(feed);
 
-        // Parser le flux avec timeout
-        const parsedFeed = await Promise.race([
-          parser.parseURL(feed.url),
-          new Promise((_, reject) =>
-            setTimeout(() => reject(new Error('Timeout')), 15000)
-          )
-        ]);
-
-        // Mettre à jour le titre et description du flux
-        await runQuery(
-          'UPDATE rss_feeds SET title = ?, description = ?, last_fetched_at = CURRENT_TIMESTAMP WHERE id = ?',
-          [parsedFeed.title || feed.url, parsedFeed.description || '', feed.id]
-        );
-
-        // Ajouter les articles (limiter à 100 par flux pour capturer plus d'articles)
-        const items = parsedFeed.items.slice(0, 100);
-        let feedArticles = 0;
-
-        for (const item of items) {
-          try {
-            if (!item.link) continue; // Skip articles sans lien
-
-            // Normaliser la date pour la comparaison
-            const pubDate = item.pubDate || item.isoDate || new Date().toISOString();
-
-            // Vérifier si l'article existe déjà par lien OU par titre+date
-            // Permet de gérer les liens qui changent (tracking) et les vrais doublons
-            const existingByLink = await getOne(
-              'SELECT id FROM rss_articles WHERE link = ?',
-              [item.link]
-            );
-
-            const existingByTitleDate = await getOne(
-              'SELECT id FROM rss_articles WHERE feed_id = ? AND title = ? AND DATE(pub_date) = DATE(?)',
-              [feed.id, item.title, pubDate]
-            );
-
-            // Ajouter seulement si n'existe ni par lien ni par titre+date
-            if (!existingByLink && !existingByTitleDate) {
-              await runQuery(
-                'INSERT INTO rss_articles (feed_id, title, link, description, pub_date, content) VALUES (?, ?, ?, ?, ?, ?)',
-                [
-                  feed.id,
-                  item.title || 'Sans titre',
-                  item.link,
-                  item.contentSnippet || item.description || '',
-                  pubDate,
-                  item.content || item['content:encoded'] || ''
-                ]
-              );
-              feedArticles++;
-              totalArticles++;
-            }
-          } catch (articleError) {
-            // Ignorer les articles en double (contrainte UNIQUE sur link)
-            if (!articleError.message.includes('UNIQUE')) {
-              logger.debug(`Article ignoré: ${articleError.message}`);
-            }
-          }
-        }
-
-        logger.info(`✓ ${feed.title || feed.url}: ${feedArticles} nouveaux articles`);
-
-      } catch (feedError) {
-        totalErrors++;
-        logger.error(`✗ Erreur fetch ${feed.url}: ${feedError.message}`);
+      if (result.success) {
+        successCount++;
+        totalNew += result.newArticles;
+      } else {
+        errorCount++;
       }
     }
 
-    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
-    logger.info(`✅ Mise à jour terminée: ${totalArticles} nouveaux articles, ${totalErrors} erreurs (${duration}s)`);
+    const totalDuration = ((Date.now() - globalStart) / 1000).toFixed(2);
+    logger.info(`✅ === Fin: ${totalNew} nouveaux articles (${successCount} OK, ${errorCount} erreurs, ${totalDuration}s) ===`);
 
-    // Invalider le cache des articles dans les routes
-    try {
-      const rssRoutes = require('../routes/rss.routes');
-      if (rssRoutes && rssRoutes.invalidateCache) {
-        rssRoutes.invalidateCache();
-        logger.debug('Cache des articles RSS invalidé');
-      }
-    } catch (err) {
-      // Ignore si la fonction n'existe pas encore
-    }
+    return {
+      feeds: feeds.length,
+      newArticles: totalNew,
+      success: successCount,
+      errors: errorCount
+    };
 
   } catch (error) {
-    logger.error('Erreur lors de la mise à jour automatique des flux RSS:', error);
+    logger.error('❌ Erreur globale fetch RSS:', error);
+    return { error: error.message };
   } finally {
     isRunning = false;
   }
 }
 
 /**
- * Démarrer le scheduler (toutes les 2 minutes pour mises à jour fréquentes)
+ * Démarrer le scheduler
  */
 function startScheduler() {
-  logger.info('📰 Scheduler RSS démarré (mise à jour toutes les 2 minutes)');
+  logger.info('📰 === RSS Scheduler V2 démarré ===');
+  logger.info(`Configuration: fetch toutes les ${FETCH_INTERVAL / 60000} minutes`);
+  logger.info(`Max articles par flux: ${MAX_ARTICLES_PER_FEED}`);
 
-  // Initialiser les flux par défaut si nécessaire, puis première exécution
-  setTimeout(async () => {
-    await initializeDefaultFeeds();
+  // Premier fetch après le démarrage
+  setTimeout(() => {
+    logger.info('🚀 Premier fetch RSS...');
     fetchAllFeeds().catch(err => {
-      logger.error('Erreur lors de la première mise à jour RSS:', err);
+      logger.error('Erreur premier fetch:', err);
     });
-  }, 5000); // Attendre 5 secondes après le démarrage du serveur
+  }, STARTUP_DELAY);
 
-  // Ensuite toutes les 2 minutes (réduit de 5 minutes pour mises à jour plus fréquentes)
+  // Fetch régulier
   setInterval(() => {
     fetchAllFeeds().catch(err => {
-      logger.error('Erreur lors de la mise à jour RSS:', err);
+      logger.error('Erreur fetch périodique:', err);
     });
-  }, 2 * 60 * 1000); // 2 minutes
+  }, FETCH_INTERVAL);
 }
 
 /**
- * Fetch manuel (utilisé par la route API)
+ * Fetch manuel (API)
  */
 async function manualFetch() {
+  logger.info('🔄 Fetch manuel déclenché');
   return await fetchAllFeeds();
 }
 
 module.exports = {
   startScheduler,
   manualFetch,
-  fetchAllFeeds,
-  initializeDefaultFeeds
+  fetchAllFeeds
 };

services/rss-scheduler.js.backup

@@ -0,0 +1,219 @@
+// Service de mise à jour automatique des flux RSS
+const Parser = require('rss-parser');
+const { getAll, getOne, runQuery } = require('../config/database');
+const logger = require('../config/logger');
+
+const parser = new Parser({
+  timeout: 10000,
+  headers: {
+    'User-Agent': 'NoteFlow RSS Reader'
+  }
+});
+
+let isRunning = false;
+
+/**
+ * Initialiser des flux RSS par défaut
+ */
+async function initializeDefaultFeeds() {
+  try {
+    const existingFeeds = await getAll('SELECT COUNT(*) as count FROM rss_feeds');
+
+    if (existingFeeds[0].count === 0) {
+      logger.info('🔧 Aucun flux RSS trouvé, ajout de flux par défaut...');
+
+      const defaultFeeds = [
+        'https://www.lemonde.fr/rss/une.xml',
+        'https://feeds.bbci.co.uk/news/world/rss.xml',
+        'https://www.lefigaro.fr/rss/figaro_actualites.xml'
+      ];
+
+      for (const url of defaultFeeds) {
+        try {
+          const feed = await parser.parseURL(url);
+          await runQuery(
+            'INSERT INTO rss_feeds (url, title, description, enabled) VALUES (?, ?, ?, 1)',
+            [url, feed.title || url, feed.description || '']
+          );
+          logger.info(`✓ Flux ajouté: ${feed.title || url}`);
+        } catch (error) {
+          logger.warn(`⚠️  Impossible d'ajouter ${url}: ${error.message}`);
+        }
+      }
+
+      logger.info('✓ Flux RSS par défaut initialisés');
+      return true;
+    }
+
+    return false;
+  } catch (error) {
+    logger.error('Erreur lors de l\'initialisation des flux par défaut:', error);
+    return false;
+  }
+}
+
+/**
+ * Récupérer et mettre à jour tous les flux RSS activés
+ */
+async function fetchAllFeeds() {
+  if (isRunning) {
+    logger.info('Fetch RSS déjà en cours, skip...');
+    return;
+  }
+
+  isRunning = true;
+  const startTime = Date.now();
+
+  try {
+    logger.info('🔄 Début de la mise à jour des flux RSS...');
+
+    // Récupérer tous les flux activés
+    const feeds = await getAll('SELECT * FROM rss_feeds WHERE enabled = 1');
+
+    if (!feeds || feeds.length === 0) {
+      logger.info('⚠️  Aucun flux RSS activé, initialisation...');
+      const initialized = await initializeDefaultFeeds();
+      if (initialized) {
+        // Réessayer avec les nouveaux flux
+        isRunning = false;
+        return await fetchAllFeeds();
+      }
+      isRunning = false;
+      return;
+    }
+
+    logger.info(`📰 Mise à jour de ${feeds.length} flux RSS...`);
+
+    let totalArticles = 0;
+    let totalErrors = 0;
+
+    // Traiter chaque flux
+    for (const feed of feeds) {
+      try {
+        logger.info(`⏳ Fetch: ${feed.url}`);
+
+        // Parser le flux avec timeout
+        const parsedFeed = await Promise.race([
+          parser.parseURL(feed.url),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Timeout')), 15000)
+          )
+        ]);
+
+        // Mettre à jour le titre et description du flux
+        await runQuery(
+          'UPDATE rss_feeds SET title = ?, description = ?, last_fetched_at = CURRENT_TIMESTAMP WHERE id = ?',
+          [parsedFeed.title || feed.url, parsedFeed.description || '', feed.id]
+        );
+
+        // Ajouter les articles (limiter à 100 par flux pour capturer plus d'articles)
+        const items = parsedFeed.items.slice(0, 100);
+        let feedArticles = 0;
+
+        for (const item of items) {
+          try {
+            if (!item.link) continue; // Skip articles sans lien
+
+            // Normaliser la date pour la comparaison
+            const pubDate = item.pubDate || item.isoDate || new Date().toISOString();
+
+            // Vérifier si l'article existe déjà par lien OU par titre+date
+            // Permet de gérer les liens qui changent (tracking) et les vrais doublons
+            const existingByLink = await getOne(
+              'SELECT id FROM rss_articles WHERE link = ?',
+              [item.link]
+            );
+
+            const existingByTitleDate = await getOne(
+              'SELECT id FROM rss_articles WHERE feed_id = ? AND title = ? AND DATE(pub_date) = DATE(?)',
+              [feed.id, item.title, pubDate]
+            );
+
+            // Ajouter seulement si n'existe ni par lien ni par titre+date
+            if (!existingByLink && !existingByTitleDate) {
+              await runQuery(
+                'INSERT INTO rss_articles (feed_id, title, link, description, pub_date, content) VALUES (?, ?, ?, ?, ?, ?)',
+                [
+                  feed.id,
+                  item.title || 'Sans titre',
+                  item.link,
+                  item.contentSnippet || item.description || '',
+                  pubDate,
+                  item.content || item['content:encoded'] || ''
+                ]
+              );
+              feedArticles++;
+              totalArticles++;
+            }
+          } catch (articleError) {
+            // Ignorer les articles en double (contrainte UNIQUE sur link)
+            if (!articleError.message.includes('UNIQUE')) {
+              logger.debug(`Article ignoré: ${articleError.message}`);
+            }
+          }
+        }
+
+        logger.info(`✓ ${feed.title || feed.url}: ${feedArticles} nouveaux articles`);
+
+      } catch (feedError) {
+        totalErrors++;
+        logger.error(`✗ Erreur fetch ${feed.url}: ${feedError.message}`);
+      }
+    }
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    logger.info(`✅ Mise à jour terminée: ${totalArticles} nouveaux articles, ${totalErrors} erreurs (${duration}s)`);
+
+    // Invalider le cache des articles dans les routes
+    try {
+      const rssRoutes = require('../routes/rss.routes');
+      if (rssRoutes && rssRoutes.invalidateCache) {
+        rssRoutes.invalidateCache();
+        logger.debug('Cache des articles RSS invalidé');
+      }
+    } catch (err) {
+      // Ignore si la fonction n'existe pas encore
+    }
+
+  } catch (error) {
+    logger.error('Erreur lors de la mise à jour automatique des flux RSS:', error);
+  } finally {
+    isRunning = false;
+  }
+}
+
+/**
+ * Démarrer le scheduler (toutes les 2 minutes pour mises à jour fréquentes)
+ */
+function startScheduler() {
+  logger.info('📰 Scheduler RSS démarré (mise à jour toutes les 2 minutes)');
+
+  // Initialiser les flux par défaut si nécessaire, puis première exécution
+  setTimeout(async () => {
+    await initializeDefaultFeeds();
+    fetchAllFeeds().catch(err => {
+      logger.error('Erreur lors de la première mise à jour RSS:', err);
+    });
+  }, 5000); // Attendre 5 secondes après le démarrage du serveur
+
+  // Ensuite toutes les 2 minutes (réduit de 5 minutes pour mises à jour plus fréquentes)
+  setInterval(() => {
+    fetchAllFeeds().catch(err => {
+      logger.error('Erreur lors de la mise à jour RSS:', err);
+    });
+  }, 2 * 60 * 1000); // 2 minutes
+}
+
+/**
+ * Fetch manuel (utilisé par la route API)
+ */
+async function manualFetch() {
+  return await fetchAllFeeds();
+}
+
+module.exports = {
+  startScheduler,
+  manualFetch,
+  fetchAllFeeds,
+  initializeDefaultFeeds
+};