data-primals-engine 1.4.1 → 1.4.3

package/src/modules/assistant/assistant.js

@@ -58,7 +58,7 @@ async function searchModels(query, user) {
         $or: [{ _user: user.username }, { _user: { $exists: false } }],
         $and: [{ $or: [{ name: { $regex: searchRegex } }, { description: { $regex: searchRegex } }] }]
     }, {
-        projection: { name: 1, description: 1, _id: 0 }
+        projection: { name: 1, description: 1, fields: 1, _id: 0 }
     }).limit(10).toArray();
 }
 
@@ -74,39 +74,49 @@ const createSystemPrompt = (modelDefs, lang) => {
 Tu es "Prior", un assistant expert en analyse de données pour le moteur data-primals-engine..
 Ta mission est d'aider l'utilisateur en répondant à ses questions sur ses données.
 
+REGLE FONDATRICE : suis les règles et ne dévie pas du chemin.
+STYLE UTILISE : apporte l'information au plus rapide, sans détours, ni sollicitation à l'utilisateur, ou à des tiers.
 
 FORMAT DE RÉPONSE OBLIGATOIRE :
 Un SEUL objet JSON valide contenant exactement 2 champs :
 1. "action" (string) 
 2. "params" (object)
-    2.1 : query (string) : Les mots clés de la recherche
-    2.2 : filter (object) : Les filtres de la recherche
-    2.3 : limit (number) : Le nombre de résultats à afficher
-    2.4 : sort (string) : La clé de tri de la recherche
-    2.6 : model (string) : Le nom du modèle à utiliser
-    2.7 : data (object) : Les données à ajouter à la base de données
-
-Tu as accès aux outils suivants. 
-
-NOUVEL OUTIL PRIORITAIRE:
-1.  **search_models**: À utiliser EN PREMIER SI TU NE SAIS PAS QUEL MODÈLE UTILISER pour répondre à la question de l'utilisateur. Si tu l'as déjà recherché, garde la définition initiale et n'effectue pas de recherche.
-    - Utilisation: { "action": "search_models", "params": { "query": "mots-clés de la recherche" } }
-    
-1.  **search**: Pour chercher des informations dans les données de l'utilisateur.
+
+Tu as accès aux outils et actions suivants.
+
+OUTILS DE RAISONNEMENT INTERNE: (Utilisés pour collecter de l'information avant de décider de l'action finale)
+1.  **search_models**: Pour rechercher les modèles de données disponibles.
+    - Utilisation: { "action": "search_models", "params": { "query": "^regexToSearchFor$" } }
+====
+
+ACTIONS FINALES: (Actions qui terminent ta réflexion et renvoient un résultat à l'utilisateur)
+1.  **search**: Pour chercher des informations et les AFFICHER à l'utilisateur sous forme de tableau.
     - Utilisation: { "action": "search", "params": { "model": "nomDuModele", "filter": {}, "limit": 10 } }
 
-2.  **post**: Pour créer une nouvelle donnée.
+2.  **post**: Pour créer une nouvelle donnée (nécessite confirmation).
     - Utilisation: { "action": "post", "params": { "model": "nomDuModele", "data": {} } }
 
-3.  **update**: Pour mettre à jour des données existantes.
+3.  **update**: Pour mettre à jour des données existantes (nécessite confirmation).
     - Utilisation: { "action": "update", "params": { "model": "nomDuModele", "filter": {}, "data": {} } }
     - filter est très pratique pour mettre à jour des données ciblées en une seule passe.
 
-4.  **delete**: Pour supprimer des données.
+4.  **delete**: Pour supprimer des données (nécessite confirmation).
     - Utilisation: { "action": "delete", "params": { "model": "nomDuModele", "filter": {} } }
 
-5.  **displayMessage**: Pour répondre directement à l'utilisateur. N'utilise cette action QUE lorsque tu as toutes les informations nécessaires pour formuler une réponse finale.
+5.  **displayMessage**: Pour répondre avec un simple message texte. N'utilise cette action QUE lorsque tu as toutes les informations nécessaires pour formuler une réponse finale.
     - Utilisation: { "action": "displayMessage", "params": { "message": "Ta réponse textuelle." } }
+    
+6.  **generateChart**: Pour créer et afficher un graphique. 
+    - Utilisation: { "action": "generateChart", "params": { ...config } }
+    - Le paramètre \`config\` doit contenir :
+        - \`title\` (string): Un titre clair pour le graphique.
+        - \`model\` (string): Le nom du modèle de données à utiliser.
+        - \`type\` (string): Le type de graphique. Peut être 'bar', 'line', 'pie', 'doughnut'.
+        - \`aggregationType\` (string): Comment agréger les données. 'count' (par défaut), 'sum', 'avg', 'min', 'max'.
+        - \`xAxis\` (string): (Pour bar/line) Le champ pour l'axe des X. Un champ de type date, enum ou string du modèle.
+        - \`groupBy\` (string): (Pour pie/doughnut) Le champ sur lequel grouper les données (un champ enum ou relation du modèle).
+        - \`yAxis\` (string): (Optionnel, sauf pour sum/avg/min/max) Le champ numérique à agréger du modèle.
+        - \`filter\` (object): (Optionnel, filtre de la recherche, même écriture stricte que pour les filtres de recherche (voir plus bas pour les exemples) 
 
 Voici le mémo pour assigner des valeurs aux champs des modèles,avec ces types de données : 
 utilise une chaine de caractère convertible en ObjectId (mongodb) lorsque le nom du champ est _id 
@@ -125,15 +135,14 @@ utilise la valeur en héxadecimal, ex: '#FF0000' pour les champs de type : color
 utilise les valeurs de cron standard '* * * * * *' pour : cronSchedule 
 
 PROCESSUS DE RAISONNEMENT:
-1. L'utilisateur pose une question.
-2. Si le nom du modèle n'est pas évident, utilise d'abord l'outil "search_models" pour trouver le bon modèle.
-3. Une fois le modèle identifié, utilise les autres outils (search, post, etc.) pour effectuer l'action.
-4. Si tu as assez d'informations, réponds à l'utilisateur avec "displayMessage".
-
-Chacune de tes réponses doit être une étape en soi, ou au plus près d'une étape.
+a- L'utilisateur pose une question, ou demande une action de ta part.
+b- Utilise l'outil **search_models** pour trouver le(s) modèle(s) qui correspondent à la question.
+ Si tu as déjà fait la recherche dans la conversation, garde la définition initiale et n'effectue pas de recherche, va directement à l'étape c
+c- Une fois la réponse retournée et intégrée, tu devras utiliser les autres outils (search, post, etc.) dans la conversation pour satisfaire la question initiale, en utilisant les informations des modèles précédents (COMMANDE FINALE)
+Si tu n'as aucune commande à exécuter directement, réponds simplement à l'utilisateur avec "displayMessage".
 
 CONTEXTE ACTUEL:
-- Date du jour de ton conversateur : ${dt}
+- Date du jour de la conversation : ${dt}
 - La langue ISO à utiliser dans la conversation : ${lang}
 - L'utilisateur a accès aux modèles de données suivants et ne peut utiliser les filtres que sur les champs associés:
 Si tu as besoin de savoir lesquels, utilise l'outil "search_models".
@@ -143,38 +152,91 @@ Si tu as besoin de savoir lesquels, utilise l'outil "search_models".
 
 Par exemple :  
 Question : Je voudrais les événements non terminés, qui ne sont pas des festivals ou des salons :
-Réponse : { "action" : "search", "params" : ${cond1} }
+Ta réponse: { "action" : "search_models", "params": { "query": "event|événement" } }
+COMMANDE FINALE : { "action" : "search", "params" : ${cond1} }
 
 Question : Donne moi les 5 nouvelles entreprises
-Réponse : { "action" : "search", "params" : ${cond2} }
+Ta réponse: { "action" : "search_models", "params": { "query": "company|entreprise" } }
+COMMANDE FINALE : { "action" : "search", "params" : ${cond2} }
 
 Question : Je veux les 10 dernières traductions ajoutées dans la langue française.
-Réponse : { "action" : "search", "params" : ${cond3} }
+Ta réponse: { "action" : "search_models", "params": { "query": "translation|traduction" } }
+COMMANDE FINALE : { "action" : "search", "params" : ${cond3} }
 
 Question : Je veux les commandes qui ont été faites par un admin ou un modérateur
-Réponse : { "action" : "search", "params" : ${cond4} }
-====
+Ta réponse: { "action" : "search_models", "params": { "query": "order|commande" } }
+COMMANDE FINALE : { "action" : "search", "params" : ${cond4} }
+
+Question : Fais-moi un camembert des produits par catégorie.
+Ta réponse: { "action" : "search_models", "params": { "query": "product|produit" } }
+COMMANDE FINALE :
+{
+  "action": "generateChart",
+  "params": {
+    "title": "Répartition des produits par catégorie",
+    "model": "product",
+    "type": "pie",
+    "groupBy": "category",
+    "aggregationType": "count",
+    "filter": { "$and": [{"$gt": ["$publishedAt", "2023-10-05T20:12:00Z"]}, {"$lte": ["$publishedAt", "2024-10-05T20:12:00Z"]} ]}
+  }
+}
 
+Absolute rules:
+====
 NEVER use the non-aggregated syntax of the MongoDB operators :
-Use { '$gt': ["$publishedAt", "2023-10-05T20:12:00Z" } } } and NOT { publishedAt: { '$gt': '2023-10-05T20:12:00Z' } } }
+Use { "$gt": ["$publishedAt", "2023-10-05T20:12:00Z" ] } and NOT { "publishedAt": { "$gt": "2023-10-05T20:12:00Z" } }
+=====
+If several filters must be combined or juxtaposed, the operators $and, $or, $nor, $not MUST be used to make the logic.
+You need at least one of these operators.
+Example : 
+Use filters like this: { "$and": [{"$gt": ["$publishedAt", "2023-10-05T20:12:00Z"]}, {"$lte": ["$publishedAt", "2024-10-05T20:12:00Z"]} ]}
+You MUST NOT write filters like this : {"$gt": ["$publishedAt", "2023-10-05T20:12:00Z"], "$lte": ["$publishedAt", "2024-10-05T20:12:00Z"]}  without the $and operator
 =====
 Et si tu dois utiliser une date :
 "2025-08-05T20:12:00Z" au lieu de { "$date": "2025-08-05T20:12:00Z" }
 =====
-Si plusieurs filtres doivent être combinés, utilise OBLIGATOIREMENT les opérateurs $and, $or, $nor, $not
-=====
-
-Règles ABSOLUES:
 - UNE SEULE COMMANDE JSON PAR RÉPONSE
 - AUCUN TEXTE HORS DU JSON
+- PAS de MARKDOWN pour formatter le JSON, juste le JSON {...} brut.
+=====
 
 Exemple d'échange correct :
 
 Ma question: Bonjour, je voudrais les requêtes effectuées aujourd'hui sur le modèle "content".
-Ta réponse:
+Ta réponse: { "action" : "search_models", "params": { "query": "request" } }
+COMMANDE FINALE : 
 { "action" : "search", "params" : { "model": "request", "filter": { "$and": [{"$gte": "${dt}"}, {"$regexMatch": { "input": "$url", "regex": "content"}}] }, "limit" : 10, "sort" : "_id:DESC" }}`;
 }
 
+/**
+ * Corrige un filtre généré par l'IA qui pourrait avoir plusieurs opérateurs
+ * au premier niveau sans les encapsuler dans un "$and".
+ * @param {object} filter - Le filtre potentiellement incorrect.
+ * @returns {object} Le filtre corrigé.
+ */
+function correctAIFilter(filter) {
+    if (!filter || typeof filter !== 'object' || Array.isArray(filter)) {
+        return filter; // Pas un objet à corriger
+    }
+
+    const keys = Object.keys(filter);
+    if (keys.length <= 1) {
+        return filter; // Rien à corriger
+    }
+
+    // Vérifie si toutes les clés sont des opérateurs (commencent par '$')
+    const allKeysAreOperators = keys.every(key => key.startsWith('$'));
+
+    if (allKeysAreOperators) {
+        logger.warn(`[Assistant] Correction d'un filtre malformé généré par l'IA. Original: ${JSON.stringify(filter)}`);
+        const andConditions = keys.map(key => ({ [key]: filter[key] }));
+        return { '$and': andConditions };
+    }
+
+    return filter; // Aucune correction nécessaire
+}
+
 /**
  * Exécute un outil (tool) non-modifiant et retourne le résultat sous forme de chaîne.
  * @param {string} action - L'action à exécuter ('search', 'search_models').
@@ -216,7 +278,7 @@ async function executeTool(action, params, user, allModels) {
 
             if (foundModels.length > 0) {
                 return "J'ai trouvé les modèles suivants qui pourraient correspondre : " +
-                        foundModels.map(m => `\n- Modèle "${m.name}": ${m.description || 'Pas de description.'}`).join('');
+                        foundModels.map(m => `\n- Modèle "${m.name}": ${m.description || 'Pas de description.'}\n- Champs: ${m.fields.map(f => JSON.stringify(f, null, 2))}`).join('');
             } else {
                 return "Je n'ai trouvé aucun modèle correspondant à votre recherche.";
             }
@@ -286,7 +348,7 @@ async function handleChatRequest(message, history, provider, context, user, conf
     // --- PRÉPARATION DE L'HISTORIQUE DE CONVERSATION ---
     const systemPrompt = createSystemPrompt([], user.lang || 'en');
     const conversationHistory = history
-        .filter(msg => !(msg.from === 'bot' && msg.text.startsWith(i18n.t('assistant.welcome'))))
+        .filter(msg => msg.text && !(msg.from === 'bot' && msg.text.startsWith(i18n.t('assistant.welcome'))))
         .map(msg => new (msg.from === 'user' ? HumanMessage : SystemMessage)(msg.text));
 
     conversationHistory.unshift(new SystemMessage(systemPrompt));
@@ -317,11 +379,38 @@ async function handleChatRequest(message, history, provider, context, user, conf
             };
         }
 
-        logger.debug(`[Assistant] Action décidée par l'IA: ${parsedResponse.action}`);
+        logger.debug(`[Assistant] Action décidée par l'IA: ${parsedResponse.action}`, parsedResponse);
         conversationHistory.push(new SystemMessage(JSON.stringify(parsedResponse)));
 
         const { action, params } = parsedResponse;
 
+        // Correction automatique du filtre généré par l'IA, qui hallucine parfois
+        if (params && params.filter) {
+            logger.debug(`[Assistant] Filtre original de l'IA: ${JSON.stringify(params.filter)}`);
+            params.filter = correctAIFilter(params.filter);
+        }
+
+        // Action de génération de graphique, gérée par le front-end
+        if (action === 'generateChart') {
+            // On retourne directement la configuration du graphique au client.
+            return { success: true, chartConfig: params };
+        }
+
+        // NOUVEAU: Action de recherche à afficher, gérée par le front-end
+        if (action === 'search') {
+            const searchResult = await searchData({
+                model: params.model,
+                filter: params.filter,
+                limit: params.limit || 10,
+                sort: params.sort
+            }, user);
+            if (searchResult.data?.length > 0) {
+                return { success: true, dataResult: { model: params.model, data: searchResult.data } };
+            } else {
+                return { success: true, displayMessage: i18n.t('assistant.search.noResults', "Je n'ai trouvé aucun résultat.") };
+            }
+        }
+
         // Actions nécessitant une confirmation de l'utilisateur
         if (['post', 'update', 'delete'].includes(action)) {
             const confirmationMessage = i18n.t('assistant.confirmActionPrompt', "Veuillez confirmer l'action suivante :");
@@ -337,8 +426,8 @@ async function handleChatRequest(message, history, provider, context, user, conf
             return { success: true, displayMessage: params.message };
         }
 
-        // Actions à exécuter immédiatement (outils)
-        if (['search', 'search_models'].includes(action)) {
+        // Outils pour le raisonnement interne de l'IA
+        if (['search_models'].includes(action)) { // On a enlevé 'search' d'ici
             const toolResult = await executeTool(action, params, user, allModels);
             conversationHistory.push(new SystemMessage(`Résultat de l'outil '${action}':\n${toolResult}`));
             continue; // On continue la boucle pour que l'IA puisse raisonner avec ce nouveau résultat

package/src/modules/bucket.js

@@ -12,6 +12,7 @@ import i18n from "../../src/i18n.js";
 import {sendEmail} from "../email.js";
 import {throttleMiddleware} from "../middlewares/throttle.js";
 import {getCollectionForUser} from "./mongodb.js";
+import {safeAssignObject} from "../core.js";
 
 const restoreRequests = {};
 
@@ -21,11 +22,11 @@ export const requestRestore = async (user, lang) => {
     const modelsRestoreToken = crypto.randomBytes(32).toString('hex');
     const expiration = new Date(Date.now() + 30 * 60 * 1000); // 30 minutes
 
-    restoreRequests[user?.username] = {
+    safeAssignObject(restoreRequests, user?.username, {
         fullToken: fullRestoreToken,
         modelsToken: modelsRestoreToken,
         expiresAt: expiration
-    };
+    });
 
     i18n.changeLanguage(lang);
 

package/src/modules/data/data.backup.js

@@ -0,0 +1,374 @@
+import {dbUrl, MongoClient, MongoDatabase} from "../../engine.js";
+import {getUserId, isDemoUser} from "../../data.js";
+import {Config} from "../../config.js";
+import {Event} from "../../events.js";
+import {getObjectHash} from "../../core.js";
+import path from "node:path";
+import {downloadFromS3, getUserS3Config, listS3Backups, uploadToS3} from "../bucket.js";
+import fs from "node:fs";
+import {modelsCache, runCryptoWorkerTask} from "./data.core.js";
+import * as tar from "tar";
+import {getCollection, getUserCollectionName, modelsCollection} from "../mongodb.js";
+import {removeFile} from "../file.js";
+import {cancelAlerts, scheduleAlerts} from "./data.scheduling.js";
+import {dbName} from "../../constants.js";
+import {scheduleWorkflowTriggers} from "../workflow.js";
+import crypto from "node:crypto";
+import process from "node:process";
+import {promisify} from "node:util";
+import {execFile} from "node:child_process";
+import AWS from "aws-sdk";
+import {Logger} from "../../gameObject.js";
+
+const getBackupDir = () => process.env.BACKUP_DIR || './backups'; // Répertoire de stockage des sauvegardes
+const execFileAsync = promisify(execFile);
+
+let engine, logger;
+export function onInit(defaultEngine) {
+    engine = defaultEngine;
+    logger = engine.getComponent(Logger);
+}
+
+export const jobDumpUserData = async () => {
+
+    try {
+
+        const primalsDb = MongoClient.db("primals");
+
+        let usersCollection = primalsDb.collection("users");
+        const users = await usersCollection.find().toArray();
+
+        users.forEach((user) => {
+            if (isDemoUser(user) && Config.Get("useDemoAccounts"))
+                return;
+            try {
+                dumpUserData(user).catch(e => {
+                    Event.Trigger("OnUserDataDumped", "event", "system", engine);
+                })
+            } catch (ignored) {
+
+            }
+        });
+
+    } catch (e) {
+        console.error(e);
+    }
+}
+let restoreRequests = {};
+export const validateRestoreRequest = (username, token) => {
+    const request = restoreRequests[username];
+    if (!request) {
+        return {error: 'Invalid username.'};
+    }
+
+    if (request.token !== token) {
+        return {error: 'Invalid token.'};
+    }
+
+    if (request.expiresAt < new Date()) {
+        delete restoreRequests[username];
+        return {error: 'Token has expired.'};
+    }
+
+    delete restoreRequests[username]; // Remove the request after validation
+    return {success: true};
+};
+export const loadFromDump = async (user, options = {}) => {
+    const {modelsOnly = false} = options;
+    const action = modelsOnly ? 'restore-models' : 'full-restore';
+    logger.info(`[${action}] Starting for user: ${user.username}`);
+
+    const encryptedKey = readKeyFromFile(user);
+    if (!encryptedKey) {
+        throw new Error("No encryption key found for this user. Cannot restore.");
+    }
+
+    const userId = getObjectHash({user: user.username});
+    const backupDir = getBackupDir();
+    let backupFilePath = ''; // Will hold the path to the archive to be restored
+    let isTempFile = false; // Flag to know if we need to delete the file later
+
+    const tmpRestoreDir = path.join(backupDir, `tmp_restore_${userId}_${Date.now()}`);
+
+    try {
+        const s3Config = await getUserS3Config(user);
+        // --- NEW LOGIC: Check for S3 config first ---
+        if (s3Config && s3Config.bucketName && s3Config.accessKeyId && s3Config.secretAccessKey) {
+            logger.info(`[${action}] S3 config found for user. Searching for backups in bucket: ${s3Config.bucketName}`);
+
+            const s3Backups = await listS3Backups(s3Config);
+            const userBackups = s3Backups
+                .filter(f => f.filename.startsWith(`backup_${userId}_`))
+                .sort((a, b) => b.timestamp - a.timestamp);
+
+            if (userBackups.length === 0) {
+                throw new Error(`No S3 backups found for user ${user.username} in bucket ${s3Config.bucketName}.`);
+            }
+
+            const latestBackup = userBackups[0];
+            logger.info(`[${action}] Found latest S3 backup: ${latestBackup.key}. Downloading...`);
+
+            // Download the file to a temporary location
+            backupFilePath = path.join(backupDir, latestBackup.filename);
+            isTempFile = true;
+            await downloadFromS3(s3Config, latestBackup.key, backupFilePath);
+            logger.info(`[${action}] S3 backup downloaded to ${backupFilePath}.`);
+
+        } else {
+            // --- FALLBACK LOGIC: Look for local backups ---
+            logger.info(`[${action}] No S3 config. Searching for local backups.`);
+            const backupFilenameRegex = new RegExp(`^backup_${userId}_(\\d+)\\.tar\\.gz$`);
+            const backupFiles = fs.readdirSync(backupDir).filter(filename => backupFilenameRegex.test(filename));
+            if (backupFiles.length === 0) {
+                throw new Error(`No local backup files found for user ${user.username}.`);
+            }
+            const latestBackupFile = backupFiles.sort((a, b) => parseInt(b.match(backupFilenameRegex)[1], 10) - parseInt(a.match(backupFilenameRegex)[1], 10))[0];
+            backupFilePath = path.join(backupDir, latestBackupFile);
+        }
+
+        // --- The rest of the logic remains the same, operating on backupFilePath ---
+
+        await runCryptoWorkerTask('decrypt', {filePath: backupFilePath, password: encryptedKey});
+
+        if (!fs.existsSync(tmpRestoreDir)) {
+            fs.mkdirSync(tmpRestoreDir, {recursive: true});
+        }
+        await tar.extract({file: backupFilePath, gzip: true, C: tmpRestoreDir, sync: true});
+
+        // ... (Cleaning logic: deleteMany, removeFile, cancelAlerts) ...
+        const datasCollection = getCollection("datas");
+        if (modelsOnly) {
+            await modelsCollection.deleteMany({_user: user.username});
+        } else {
+            await datasCollection.deleteMany({_user: user.username});
+            await modelsCollection.deleteMany({_user: user.username});
+
+            const filesCollection = getCollection("files");
+            const userFiles = await filesCollection.find({user: user.username, _model: "privateFile"}).toArray();
+            for (const file of userFiles) {
+                await removeFile(file.guid, user).catch(e => logger.error(e.message));
+            }
+            await cancelAlerts(user);
+            logger.info(`[${action}] Cleaned existing data, models, files, and alerts for user ${user.username}.`);
+        }
+
+        // --- EXÉCUTION DE MONGORESTORE ---
+        const restoreSourceDir = path.join(tmpRestoreDir, dbName);
+        if (!fs.existsSync(restoreSourceDir)) {
+            throw new Error(`Restore source directory (${restoreSourceDir}) not found.`);
+        }
+
+        let command;
+        const args = [
+            '--uri', dbUrl,
+            '--db', dbName
+        ];
+
+        if (modelsOnly) {
+            args.push('--nsInclude', `${dbName}.models`);
+        } else {
+            // mongorestore accepte plusieurs fois l'option --nsInclude
+            args.push('--nsInclude', `${dbName}.datas`);
+            args.push('--nsInclude', `${dbName}.models`);
+        }
+        // Le répertoire source est le dernier argument
+        args.push(restoreSourceDir);
+
+
+        logger.info(`[${action}] Executing restore command: ${command}`);
+        await execFileAsync('mongorestore', args);
+
+        // ... (Post-restore tasks) ...
+        await scheduleAlerts();
+        await scheduleWorkflowTriggers();
+        modelsCache.flushAll();
+
+        logger.info(`[${action}] Restore successful for user ${user.username}.`);
+        await Event.Trigger("OnDataRestored", "event", "system");
+
+    } finally {
+        // --- GUARANTEED CLEANUP ---
+        if (fs.existsSync(tmpRestoreDir)) {
+            await fs.promises.rm(tmpRestoreDir, {recursive: true, force: true});
+        }
+
+        // Re-encrypt the original file if it's not a temporary one
+        if (fs.existsSync(backupFilePath) && !isTempFile) {
+            await runCryptoWorkerTask('encrypt', {filePath: backupFilePath, password: encryptedKey});
+        }
+
+        // If we downloaded a temp file from S3, delete it
+        if (fs.existsSync(backupFilePath) && isTempFile) {
+            fs.unlinkSync(backupFilePath);
+            logger.info(`[${action}] Deleted temporary downloaded backup file: ${backupFilePath}`);
+        }
+    }
+};
+// Fonction pour générer une clé aléatoire et la stocker dans un fichier
+const generateAndStoreKey = (user) => {
+    const backupDir = getBackupDir();
+    const keyFile = path.join(backupDir, getObjectHash({id: getUserId(user)}) + '_encryption.key');
+    const key = crypto.randomBytes(16).toString('hex');
+    fs.writeFileSync(keyFile, key, {mode: 0o600}); // Permissions strictes
+    return key;
+};
+// Fonction pour lire la clé depuis le fichier
+const readKeyFromFile = (user) => {
+    const backupDir = getBackupDir();
+    const keyFile = path.join(backupDir, getObjectHash({id: getUserId(user)}) + '_encryption.key');
+    if (fs.existsSync(keyFile)) {
+        return fs.readFileSync(keyFile, 'utf8');
+    }
+    return null;
+};
+export const dumpUserData = async (user) => {
+    const s3Config = await getUserS3Config(user);
+    const backupDir = getBackupDir();
+    const userId = getObjectHash({user: user.username});
+    const backupFilename = `backup_${userId}`;
+    const timestamp = Date.now();
+
+    // Déclarer les chemins ici pour qu'ils soient accessibles dans tout le scope de la fonction
+    const localTempDumpDir = path.join(backupDir, `${backupFilename}_${timestamp}_temp`);
+    const finalArchiveName = `${backupFilename}_${timestamp}.tar.gz`;
+    const localArchivePath = path.join(backupDir, finalArchiveName);
+
+    let encryptedKey = readKeyFromFile(user);
+    if (!encryptedKey) {
+        encryptedKey = generateAndStoreKey(user);
+    }
+
+    try {
+        const backupFrequency = await engine.userProvider.getBackupFrequency(user);
+        logger.info(`Fréquence de sauvegarde : ${backupFrequency}.`);
+
+        const collections = await MongoDatabase.listCollections().toArray();
+        for (const collection of collections) {
+            const collsToBackup = [await getUserCollectionName(user), 'models'];
+            if (collsToBackup.includes(collection.name)) {
+                const query = {_user: user.username};
+                const args = [
+                    '--uri', dbUrl,
+                    '--db', dbName,
+                    '--out', localTempDumpDir,
+                    '--collection', collection.name,
+                    '--query', JSON.stringify(query)
+                ];
+                logger.info(`Exécution de la commande : mongodump ${args.join(' ')}`);
+                await execFileAsync('mongodump', args);
+            }
+        }
+        const dumpSourceDir = path.join(localTempDumpDir, dbName);
+        if (fs.existsSync(dumpSourceDir)) {
+            await tar.create({gzip: true, file: localArchivePath, C: localTempDumpDir}, [dbName]);
+            logger.info(`Archive de sauvegarde locale créée : ${localArchivePath}`);
+        } else {
+            logger.warn(`Le répertoire de dump ${dumpSourceDir} était vide. Aucune archive n'a créée.`);
+            return Promise.resolve();
+        }
+
+        await runCryptoWorkerTask('encrypt', {filePath: localArchivePath, password: encryptedKey});
+
+        try {
+            // Attempt the S3 upload
+            await uploadToS3(s3Config, localArchivePath, finalArchiveName);
+            // ONLY if the upload succeeds, delete the local file.
+            fs.unlinkSync(localArchivePath);
+            logger.info(`Local archive ${finalArchiveName} deleted after successful S3 upload.`);
+        } catch (e) {
+        }
+
+        logger.info(`Sauvegarde réussie pour l'utilisateur ${user.username}.`);
+        await manageBackupRotation(user, await engine.userProvider.getBackupFrequency(user), s3Config);
+
+    } catch (error) {
+        logger.error(`Erreur lors de la sauvegarde pour l'utilisateur ${user.username}:`, error);
+        // Nettoyage de l'archive si elle a été créée avant l'erreur
+        if (fs.existsSync(localArchivePath)) {
+            fs.unlinkSync(localArchivePath);
+        }
+        throw error; // Relancer l'erreur pour que l'appelant soit informé
+    } finally {
+        // --- NETTOYAGE GARANTI ---
+        // Ce bloc s'exécute toujours, que la sauvegarde réussisse ou échoue.
+        if (fs.existsSync(localTempDumpDir)) {
+            fs.rmSync(localTempDumpDir, {recursive: true, force: true});
+            logger.info(`Répertoire de dump temporaire ${localTempDumpDir} supprimé.`);
+        }
+    }
+};
+
+async function manageBackupRotation(user, backupFrequency, s3Config = null) { // Accepter s3Config
+    const userId = getObjectHash({user: user.username});
+    let filesToManage = [];
+
+    if (s3Config && s3Config.bucketName && s3Config.accessKeyId && s3Config.secretAccessKey) {
+        logger.info(`Gestion de la rotation des sauvegardes S3 pour ${userId}.`);
+        const s3Backups = await listS3Backups(s3Config);
+        // Filtrer pour ne garder que les backups de cet utilisateur et trier
+        filesToManage = s3Backups
+            .filter(f => f.filename.startsWith(`backup_${userId}_`) && f.filename.endsWith('.tar.gz'))
+            .map(f => ({
+                name: f.filename,
+                key: f.key,
+                timestamp: f.timestamp
+            })) // listS3Backups devrait fournir le timestamp
+            .sort((a, b) => b.timestamp - a.timestamp); // Tri décroissant (plus récent en premier)
+
+    } else {
+        logger.info(`Gestion de la rotation des sauvegardes locales pour ${userId}.`);
+        const backupDir = getBackupDir();
+        const localFiles = fs.readdirSync(backupDir);
+        filesToManage = localFiles
+            .filter(f => !fs.lstatSync(path.join(backupDir, f)).isDirectory() && f.startsWith(`backup_${userId}_`) && f.endsWith('.tar.gz'))
+            .map(f => {
+                const match = f.match(/_(\d+)\.tar\.gz$/);
+                return {name: f, key: path.join(backupDir, f), timestamp: match ? parseInt(match[1], 10) : 0};
+            })
+            .sort((a, b) => b.timestamp - a.timestamp); // Tri décroissant
+    }
+
+    let maxFilesToKeep;
+    // ... (ta logique existante pour maxFilesToKeep basée sur backupFrequency)
+    switch (backupFrequency) {
+    case 'daily': // Premium
+        maxFilesToKeep = 7; // Garder 7 jours
+        break;
+    case 'weekly': // Standard
+        maxFilesToKeep = 4; // Garder 4 semaines
+        break;
+    case 'monthly': // Free
+    default:
+        maxFilesToKeep = 2; // Garder 2 mois
+        break;
+    }
+    logger.info(`Rotation pour ${userId}: fréquence ${backupFrequency}, garde ${maxFilesToKeep} sauvegardes.`);
+
+
+    if (filesToManage.length > maxFilesToKeep) {
+        const filesToDelete = filesToManage.slice(maxFilesToKeep);
+        logger.info(`Suppression de ${filesToDelete.length} anciennes sauvegardes pour ${userId}.`);
+
+        const deletionPromises = filesToDelete.map(async (fileInfo) => {
+            try {
+                if (s3Config && s3Config.bucketName) {
+                    const s3 = new AWS.S3({ /* ... config ... */
+                        accessKeyId: s3Config.accessKeyId,
+                        secretAccessKey: s3Config.secretAccessKey,
+                        region: s3Config.region
+                    });
+                    await s3.deleteObject({Bucket: s3Config.bucketName, Key: fileInfo.key}).promise();
+                    logger.info(`Ancienne sauvegarde S3 supprimée : ${fileInfo.key}`);
+                } else {
+                    await fs.promises.unlink(fileInfo.key); // key est le chemin complet pour les fichiers locaux
+                    logger.info(`Ancienne sauvegarde locale supprimée : ${fileInfo.name}`);
+                }
+            } catch (err) {
+                logger.error(`Erreur lors de la suppression de l'ancienne sauvegarde ${fileInfo.name || fileInfo.key}:`, err);
+            }
+        });
+        await Promise.allSettled(deletionPromises);
+    } else {
+        logger.info(`Aucune ancienne sauvegarde à supprimer pour ${userId} (total: ${filesToManage.length}, garde: ${maxFilesToKeep}).`);
+    }
+}