data-primals-engine 1.2.1 → 1.2.2

package/src/modules/bucket.js

@@ -3,7 +3,6 @@ import AWS from "aws-sdk";
 import fs from "node:fs";
 import path from "node:path";
 import {decryptValue, encryptValue} from "../data.js";
-import {MongoClient} from "../engine.js";
 import {loadFromDump, validateRestoreRequest} from "./data.js";
 import {Logger} from "../gameObject.js";
 import {middlewareAuthenticator, userInitiator} from "./user.js";
@@ -12,6 +11,7 @@ import crypto from "node:crypto";
 import i18n from "../../src/i18n.js";
 import {sendEmail} from "../email.js";
 import {throttleMiddleware} from "../middlewares/throttle.js";
+import {getCollectionForUser} from "./mongodb.js";
 
 const restoreRequests = {};
 
@@ -54,14 +54,77 @@ const getDefaultS3Config = () => {
         bucketName: process.env.AWS_BUCKET || awsDefaultConfig.bucketName
     };
 }
-const getS3Client = (s3Config) => {
 
-    const decryptedSecretAccessKey = decryptValue(s3Config.secretAccessKey);
+/**
+ * Récupère la configuration S3 depuis les variables d'environnement de l'utilisateur en base de données.
+ * @param {object} user - L'objet utilisateur.
+ * @returns {Promise<object>} - Un objet contenant la configuration S3 trouvée pour l'utilisateur.
+ */
+async function _getUserS3ConfigFromDb(user) {
+    if (!user || !user.username) {
+        return {}; // Pas d'utilisateur, pas de configuration spécifique.
+    }
+
+    try {
+        const collection = await getCollectionForUser(user);
+        const userEnvVars = await collection.find({
+            _model: 'env',
+            _user: user.username,
+            // On ne cherche que les clés pertinentes pour optimiser la requête
+            key: { $in: ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_REGION', 'AWS_BUCKET_NAME'] }
+        }).toArray();
+
+        // Transforme le tableau de documents [{key, value}, ...] en un objet de configuration.
+        return userEnvVars.reduce((config, envVar) => {
+            if (envVar.key === 'AWS_ACCESS_KEY_ID') config.accessKeyId = envVar.value;
+            if (envVar.key === 'AWS_SECRET_ACCESS_KEY') config.secretAccessKey = envVar.value; // La clé est déjà chiffrée en BDD
+            if (envVar.key === 'AWS_REGION') config.region = envVar.value;
+            if (envVar.key === 'AWS_BUCKET_NAME') config.bucketName = envVar.value;
+            return config;
+        }, {});
 
-    const defaultConfig = getDefaultS3Config();
+    } catch (error) {
+        logger.error(`Failed to fetch user S3 config from DB for ${user.username}:`, error);
+        return {}; // Retourne un objet vide en cas d'erreur pour utiliser le fallback.
+    }
+}
+
+/**
+ * Récupère la configuration S3 effective en priorisant celle de l'utilisateur
+ * puis en se rabattant sur la configuration globale de l'environnement.
+ * C'est la fonction à utiliser pour toute opération S3.
+ * @param {object} user - L'objet utilisateur.
+ * @returns {Promise<object>} - L'objet de configuration S3 final.
+ */
+export async function getUserS3Config(user) {
+    // 1. Récupérer la configuration globale par défaut
+    const defaultConfig = {
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        region: process.env.AWS_REGION || awsDefaultConfig.region,
+        bucketName: process.env.AWS_BUCKET_NAME || awsDefaultConfig.bucketName
+    };
+
+    // 2. Récupérer la configuration spécifique de l'utilisateur
+    const userConfig = await _getUserS3ConfigFromDb(user);
+
+    if( userConfig.bucketName && userConfig.accessKeyId && userConfig.secretAccessKey) {
+        // 3. Fusionner les configurations, en donnant la priorité à celle de l'utilisateur
+        return {
+            accessKeyId: userConfig.accessKeyId || defaultConfig.accessKeyId,
+            secretAccessKey: userConfig.secretAccessKey || defaultConfig.secretAccessKey,
+            region: userConfig.region || defaultConfig.region,
+            bucketName: userConfig.bucketName || defaultConfig.bucketName
+        };
+    }
+    console.log({defaultConfig})
+    return defaultConfig;
+}
+const getS3Client = (s3Config) => {
+
+    const decryptedSecretAccessKey = s3Config.secretAccessKey ? decryptValue(s3Config.secretAccessKey): undefined;
 
     return new AWS.S3({
-        ...defaultConfig,
         accessKeyId: s3Config.accessKeyId || defaultConfig.accessKeyId,
         secretAccessKey: decryptedSecretAccessKey ? decryptedSecretAccessKey : defaultConfig.secretAccessKey,
         region: s3Config.region || defaultConfig.region,
@@ -74,6 +137,10 @@ export const uploadToS3 = async (s3Config, filePath, remoteFilename) => {
     const fileContent = fs.readFileSync(filePath);
     const bucketPath = s3Config.pathPrefix ? `${s3Config.pathPrefix.replace(/\/$/, "")}/${remoteFilename}` : remoteFilename;
 
+    if( !s3.accessKeyId || !s3.secretAccessKey || !s3.bucketName) {
+        throw new Error('Missing S3 configuration');
+    }
+
     const params = {
         Bucket: s3Config.bucketName,
         Key: bucketPath,
@@ -90,6 +157,7 @@ export const uploadToS3 = async (s3Config, filePath, remoteFilename) => {
     }
 };
 
+
 export const listS3Backups = async (s3Config) => {
     const s3 = getS3Client(s3Config);
     const bucketPathPrefix = s3Config.pathPrefix ? `${s3Config.pathPrefix.replace(/\/$/, "")}/` : '';
@@ -133,6 +201,48 @@ export const downloadFromS3 = async (s3Config, s3FileKey, downloadPath) => {
     }
 };
 
+export const deleteFromS3 = async (s3Config, remoteFilename) => {
+    const s3 = getS3Client(s3Config);
+    const bucketPath = s3Config.pathPrefix ? `${s3Config.pathPrefix.replace(/\/$/, "")}/${remoteFilename}` : remoteFilename;
+
+    const params = {
+        Bucket: s3Config.bucketName,
+        Key: bucketPath
+    };
+
+    try {
+        await s3.deleteObject(params).promise();
+        console.log(`Fichier supprimé avec succès de S3 : ${bucketPath}`);
+    } catch (err) {
+        console.error("Erreur lors de la suppression sur S3 :", err);
+        throw err;
+    }
+};
+
+/**
+ * Crée un flux de lecture pour un objet depuis un bucket S3.
+ * @param {object} s3Config - La configuration S3 (bucketName, accessKeyId, secretAccessKey, region).
+ * @param {string} s3Key - La clé (nom du fichier) de l'objet sur S3.
+ * @returns {import('stream').Readable} - Le flux de lecture de l'objet S3.
+ */
+export const getS3Stream = (s3Config, s3Key) => {
+    if (!s3Config || !s3Config.bucketName || !s3Key) {
+        throw new Error("La configuration S3 et la clé de l'objet sont requises pour créer un flux.");
+    }
+
+    // On utilise la fonction existante qui gère le déchiffrement !
+    const s3 = getS3Client(s3Config);
+
+    const params = {
+        Bucket: s3Config.bucketName,
+        Key: s3Key
+    };
+
+    // getObject().createReadStream() retourne directement un flux lisible.
+    // Les erreurs (ex: objet non trouvé) seront émises sur l'événement 'error' de ce flux.
+    return s3.getObject(params).createReadStream();
+};
+
 const throttle = throttleMiddleware(maxBytesPerSecondThrottleData);
 
 let engine, logger;

package/src/modules/data.js

@@ -3,35 +3,30 @@ import {BSON, ObjectId} from "mongodb";
 import * as util from 'node:util';
 import {promisify} from 'node:util';
 import crypto from "node:crypto";
-import {exec,execFile} from 'node:child_process';
+import {exec, execFile} from 'node:child_process';
 import sanitizeHtml from 'sanitize-html';
 import * as tar from "tar";
 import process from "node:process";
 import {randomColor} from "randomcolor";
 import cronstrue from 'cronstrue/i18n.js';
-import { setTimeoutMiddleware } from '../middlewares/timeout.js';
-import { mkdir } from 'node:fs/promises';
+import {setTimeoutMiddleware} from '../middlewares/timeout.js';
+import {mkdir} from 'node:fs/promises';
+import {anonymizeText, getDefaultForType, getFieldValueHash, getUserId, isDemoUser, isLocalUser} from "../data.js";
 import {
-    anonymizeText,
-    encryptValue,
-    getDefaultForType,
-    getFieldValueHash,
-    getUserId, isDemoUser,
-    isLocalUser
-} from "../data.js";
-import {
-    allowedFields, availableLangs,
+    allowedFields,
     dbName,
-    install, maxAlertsPerUser,
+    install,
+    maxAlertsPerUser,
     maxBytesPerSecondThrottleData,
     maxExportCount,
     maxFileSize,
-    maxFilterDepth, maxMagnetsDataPerModel, maxMagnetsModels,
+    maxFilterDepth,
+    maxMagnetsDataPerModel,
+    maxMagnetsModels,
     maxModelNameLength,
     maxModelsPerUser,
     maxPasswordLength,
     maxPostData,
-    maxPrivateFileSize,
     maxRelationsPerData,
     maxRequestData,
     maxRichTextLength,
@@ -39,7 +34,8 @@ import {
     maxTotalDataPerUser,
     megabytes,
     optionsSanitizer,
-    searchRequestTimeout, storageSafetyMargin
+    searchRequestTimeout,
+    storageSafetyMargin
 } from "../constants.js";
 import {
     getCollection,
@@ -51,16 +47,8 @@ import {
 } from "./mongodb.js";
 import {dbUrl, MongoClient, MongoDatabase} from "../engine.js";
 import path from "node:path";
-import {
-    event_trigger,
-    getFileExtension,
-    getObjectHash,
-    getRandom,
-    isGUID,
-    isPlainObject,
-    randomDate,
-    uuidv4
-} from "../core.js";
+import {getFileExtension, getObjectHash, getRandom, isGUID, isPlainObject, randomDate, uuidv4} from "../core.js";
+import {Event} from "../events.js";
 import fs from "node:fs";
 import schedule from "node-schedule";
 import {middleware} from "../middlewares/middleware-mongodb.js";
@@ -75,12 +63,14 @@ import NodeCache from "node-cache";
 import AWS from 'aws-sdk';
 import {openaiJobModel} from "../openai.jobs.js";
 import checkDiskSpace from "check-disk-space";
-import { fileURLToPath } from 'url';
-import { Worker } from 'worker_threads';
+import {fileURLToPath} from 'url';
+import {Worker} from 'worker_threads';
 import {addFile, encryptFile, removeFile} from "./file.js";
-import {listS3Backups, uploadToS3} from "./bucket.js";
+import {downloadFromS3, getS3Stream, getUserS3Config, listS3Backups, uploadToS3} from "./bucket.js";
 import {
-    calculateTotalUserStorageUsage, generateLimiter, hasPermission,
+    calculateTotalUserStorageUsage,
+    generateLimiter,
+    hasPermission,
     middlewareAuthenticator,
     userInitiator
 } from "./user.js";
@@ -132,6 +122,7 @@ export function sendSseToUser(username, data) {
     const res = sseConnections.get(username);
     if (res) {
         res.write(`data: ${JSON.stringify(data)}\n\n`);
+        Event.Trigger("sendSseToUser", "system", "calls");
         return true;
     }
     logger.warn(`[SSE] Attempted to send event to disconnected user: ${username}`);
@@ -155,12 +146,13 @@ export const jobDumpUserData = async () => {
                 return;
             try {
                 dumpUserData(user).catch(e => {
-
+                    Event.Trigger("OnUserDataDumped", "event", "system", engine);
                 })
             } catch (ignored) {
 
             }
         });
+
     }catch (e) {
         console.error(e);
     }
@@ -1210,7 +1202,11 @@ export const editModel = async (user, id, data) => {
             logger.error(`Erreur asynchrone lors du déclenchement des workflows pour ${model._model} ID ${model._id}:`, workflowError);
         });
 
-        return ({ success: true, data: await modelsCollection.findOne({_id : oid}) });
+        const newModel = await modelsCollection.findOne({_id : oid});
+        const res = ({ success: true, data: newModel });
+        const plugin = Event.Trigger("OnModelEdited", "event", "system", engine, newModel);
+        Event.Trigger("OnModelEdited", "event", "user", plugin?.data || newModel);
+        return plugin || res
     } catch (e) {
         logger.error(e);
         return ({ success: false, error: e.message, statusCode: 500 });
@@ -2111,7 +2107,7 @@ export async function onInit(defaultEngine) {
                 await cancelAlerts(req.me);
 
                 await getPromise();
-                event_trigger('jobAddUserData', req.me.username);
+                Event.Trigger('jobAddUserData', req.me.username);
             }else{
                 await getPromise();
             }
@@ -2850,12 +2846,24 @@ export async function onInit(defaultEngine) {
             const resourceInfo = await getResource(guid, user); // Passez l'objet utilisateur
             res.setHeader('Content-Type', resourceInfo.mimeType);
 
-            const fileStream = fs.createReadStream(resourceInfo.filepath);
-            fileStream.on('error', (streamError) => {
-                console.error(`Stream error for resource ${guid}:`, streamError); // ou logger.error
-                res.status(404).json({ error: 'Resource file not found on server.' });
-            });
-            fileStream.pipe(res);
+            if (resourceInfo.storage === 's3') {
+                const s3Config = await getUserS3Config(user);
+                const s3Stream = getS3Stream(s3Config, resourceInfo.s3Key);
+
+                s3Stream.on('error', (s3Error) => {
+                    logger.error(`S3 stream error for resource ${guid}:`, s3Error);
+                    res.status(404).json({ error: 'Resource file not found in storage.' });
+                });
+
+                s3Stream.pipe(res);
+            } else { // Stockage 'local'
+                const fileStream = fs.createReadStream(resourceInfo.filepath);
+                fileStream.on('error', (streamError) => {
+                    console.error(`Stream error for resource ${guid}:`, streamError); // ou logger.error
+                    res.status(404).json({error: 'Resource file not found on server.'});
+                });
+                fileStream.pipe(res);
+            }
 
         } catch (error) {
             console.error(`Error serving resource ${req.params.guid}:`, error); // ou logger.error
@@ -2892,7 +2900,7 @@ export const getModel = async (modelName, user) => {
     return model;
 }
 export const getModels = async ()  => {
-    return await getCollection('models').find({'$or': [{_user: { $exists: false}}]}).toArray();
+    return await getCollection('models')?.find({'$or': [{_user: { $exists: false}}]}).toArray() || [];
 }
 
 
@@ -3119,9 +3127,10 @@ export const insertData = async (modelName, data, files, user, triggerWorkflow =
             // Attendre que toutes les opérations post-insertion (workflows, planification) soient tentées
             await Promise.allSettled(postInsertionPromises);
         }
-
-        // --- Retourner succès car l'insertion principale a réussi ---
-        return { success: true, insertedIds: insertedIds.map(id => id.toString()) }; // Convertir les IDs en string pour la réponse
+        const res = { success: true, insertedIds: insertedIds.map(id => id.toString()) }; // Convertir les IDs en string pour la réponse
+        const plugin = Event.Trigger("OnDataAdded", "event", "system", engine, insertedIds);
+        Event.Trigger("OnDataAdded", "event", "user", plugin?.insertedIds || insertedIds);
+        return plugin || res;
 
     } catch (error) { // Attrape les erreurs de permission ou de pushDataUnsecure
         logger.error(`[insertData] Main error during insertion process for model ${modelName}: ${error.message}`, error.stack);
@@ -3633,27 +3642,48 @@ const checkHash = async (me, model, hash, excludeId = null) => {
     return count > 0;
 };
 
+
 export const getResource = async (guid, user) => {
     if (!guid) throw new Error("Le GUID du fichier est requis.");
     if (!isGUID(guid)) throw new Error("Le GUID du fichier n'est pas valide.");
 
     const collection = getCollection("files");
-
-    // Trouver le fichier et vérifier l'autorisation (propriétaire, admin ou utilisateur principal)
     const file = await collection.findOne({ guid });
-    if (!file) throw new Error("Fichier non trouvé."+guid);
 
+    if (!file) {
+        throw new Error("Fichier non trouvé.");
+    }
+
+    // La vérification des permissions reste la même...
     if (user.username !== 'demo' && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_READ_FILE", `API_READ_FILE_privateFile_${guid}`], user)) {
-        if (file._user !== (user._user || user.username)) { // Vérifier si l'utilisateur est le propriétaire
+        if (file.user !== (user._user || user.username)) {
             throw new Error("Vous n'êtes pas autorisé à accéder à ce fichier.");
         }
     }
-    // Construire le chemin vers le fichier
-    const filepath = path.join(process.cwd(), 'uploads', 'private', guid)+'.'+getFileExtension(file.filename);
-    if (!fs.existsSync(filepath)) throw new Error("Fichier non trouvé sur le serveur.");
 
-
-    return { success: true, filepath, filename: file.filename, mimeType: file.mimeType }; // Retourner des informations utiles
+    // On retourne des informations différentes selon le type de stockage
+    if (file.storage === 's3') {
+        return {
+            success: true,
+            storage: 's3',
+            s3Key: file.filename, // 'filename' contient la clé S3
+            mimeType: file.mimeType
+            // Idlement, on aurait aussi le nom de fichier original ici
+        };
+    } else { // Par défaut, on considère le stockage local
+        // On utilise le chemin stocké en base de données
+        const filepath = file.path;
+        if (!filepath || !fs.existsSync(filepath)) {
+            throw new Error("Fichier non trouvé sur le serveur.");
+        }
+        return {
+            success: true,
+            storage: 'local',
+            filepath: filepath,
+            filename: file.filename,
+            mimeType: file.mimeType
+        };
+    }
 };
 
 export const patchData = async (modelName, filter, data, files, user, triggerWorkflow = true, waitForWorkflow = false) => {
@@ -4088,7 +4118,10 @@ export const deleteData = async (modelName, filter, user ={}, triggerWorkflow, w
             logger.info(`[deleteData] No documents to delete for user ${user?.username} after permission checks or matching criteria.`);
         }
 
-        return ({ success: true, deletedCount });
+        const res = { success: true, deletedCount }
+        const plugin = Event.Trigger("OnDataDeleted", "event", "system", engine, {model:modelName, filter});
+        Event.Trigger("OnDataDeleted", "event", "user", {model:modelName, filter});
+        return plugin || res;
 
     } catch (error) {
         logger.error(`[deleteData] Error during deletion process for user ${user?.username}:`, error);
@@ -4598,7 +4631,10 @@ export const searchData = async (query, user) => {
     let data = await prom.toArray();
     data = await handleFields(modelElement, data, user);
 
-    return {data, count: count[0]?.count || 0};
+    const res = {data, count: count[0]?.count || 0};
+    const plugin = Event.Trigger("OnDataSearched", "event", "system", engine, {data, count: count[0]?.count});
+    Event.Trigger("OnDataSearched", "event", "user", plugin || {data, count: count[0]?.count});
+    return plugin || res;
 }
 
 export const importData = async(options, files, user) => {
@@ -4909,8 +4945,7 @@ export const importData = async(options, files, user) => {
             importJobs[importJobId].errors.push(error.message || "An unhandled error occurred in background process.");
         }
     });
-
-    return ({ success: true, message: "Import initiated. Check progress via SSE.", job: importJob });
+    return ({success: true, message: "Import initiated. Check progress via SSE.", job: importJob});
 }
 
 export const exportData= async (options, user) =>{
@@ -5025,7 +5060,10 @@ export const exportData= async (options, user) =>{
         exportResults._exportErrors = errors;
     }
 
-    return { success: true, data: exportResults, models: modelsToExport };
+    const res = { success: true, data: exportResults, models: modelsToExport };
+    const plugin = Event.Trigger("OnDataExported", "event", "system", engine, exportResults, modelsToExport);
+    Event.Trigger("OnDataExported", "event", "user", plugin?.exportResults || exportResults, plugin?.modelsToExport || modelsToExport);
+    return plugin || res;
 }
 
 function handleCalculationExpression(calcExpression, fi, modelElement, calculationName) {
@@ -5270,43 +5308,68 @@ export const loadFromDump = async (user, options = {}) => {
     const action = modelsOnly ? 'restore-models' : 'full-restore';
     logger.info(`[${action}] Starting for user: ${user.username}`);
 
-    let encryptedKey = readKeyFromFile(user);
+    const encryptedKey = readKeyFromFile(user);
     if (!encryptedKey) {
         throw new Error("No encryption key found for this user. Cannot restore.");
     }
 
-    const userId = getObjectHash({user: user.username});
-    // --- La logique pour trouver le fichier de backup (local ou S3) reste la même ---
-    // (le code existant pour trouver/télécharger le backupFilePath va ici)
-    // ...
-    let backupFilePath; // Assurez-vous que cette variable est bien définie avec le chemin du fichier .tar.gz
-    // Exemple simplifié :
+    const userId = getObjectHash({ user: user.username });
     const backupDir = getBackupDir();
-    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(`Aucun fichier de sauvegarde local trouvé pour l'utilisateur ${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);
-    // --- Fin de la logique de recherche de fichier ---
+    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 });
 
-        // --- NETTOYAGE SÉCURISÉ AVANT RESTAURATION ---
+        // ... (Cleaning logic: deleteMany, removeFile, cancelAlerts) ...
         const datasCollection = getCollection("datas");
-
         if (modelsOnly) {
-            // Supprime uniquement les modèles de l'utilisateur
             await modelsCollection.deleteMany({ _user: user.username });
-            logger.info(`[${action}] Deleted existing models for user ${user.username}.`);
         } else {
-            // Restauration complète : supprime les données, modèles, fichiers et alertes de l'utilisateur
             await datasCollection.deleteMany({ _user: user.username });
             await modelsCollection.deleteMany({ _user: user.username });
 
@@ -5344,23 +5407,31 @@ export const loadFromDump = async (user, options = {}) => {
 
         logger.info(`[${action}] Executing restore command: ${command}`);
         await execFileAsync('mongorestore', args);
-        
-        // --- Tâches Post-Restauration ---
+
+        // ... (Post-restore tasks) ...
         await scheduleAlerts();
         await scheduleWorkflowTriggers();
-        modelsCache.flushAll(); // Vider le cache des modèles
+        modelsCache.flushAll();
 
         logger.info(`[${action}] Restore successful for user ${user.username}.`);
+        Event.Trigger("OnDataRestored", "event", "system");
 
     } finally {
-        // --- Nettoyage final ---
+        // --- GUARANTEED CLEANUP ---
         if (fs.existsSync(tmpRestoreDir)) {
             await fs.promises.rm(tmpRestoreDir, { recursive: true, force: true });
         }
-        // Il est préférable de rechiffrer le fichier de backup après l'avoir utilisé
-        if (fs.existsSync(backupFilePath)) {
+
+        // 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}`);
+        }
     }
 };
 
@@ -5384,7 +5455,7 @@ const readKeyFromFile = (user) => {
 };
 
 export const dumpUserData = async (user) => {
-    const s3Config = user.configS3;
+    const s3Config = await getUserS3Config(user);
     const backupDir = getBackupDir();
     const userId = getObjectHash({ user: user.username });
     const backupFilename = `backup_${userId}`;
@@ -5420,28 +5491,28 @@ export const dumpUserData = async (user) => {
                 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 été créée.`);
-            // On s'arrête ici car il n'y a rien à traiter
+            logger.warn(`Le répertoire de dump ${dumpSourceDir} était vide. Aucune archive n'a créée.`);
             return Promise.resolve();
         }
 
-        await encryptFile(localArchivePath, encryptedKey);
+        await runCryptoWorkerTask('encrypt', { filePath: localArchivePath, password: encryptedKey });
 
-        if (s3Config && s3Config.bucketName) {
+        try {
+            // Attempt the S3 upload
             await uploadToS3(s3Config, localArchivePath, finalArchiveName);
-            fs.unlinkSync(localArchivePath); // Supprime l'archive locale après l'upload
-        } else {
-            logger.info(`Aucune configuration S3 trouvée. La sauvegarde reste locale : ${localArchivePath}.`);
+            // 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, backupFrequency, s3Config);
+        await manageBackupRotation(user, await engine.userProvider.getBackupFrequency(user), s3Config);
 
     } catch (error) {
         logger.error(`Erreur lors de la sauvegarde pour l'utilisateur ${user.username}:`, error);
@@ -5463,8 +5534,8 @@ async function manageBackupRotation(user, backupFrequency, s3Config = null) { //
     const userId = getObjectHash({user:user.username});
     let filesToManage = [];
 
-    if (s3Config && s3Config.bucketName) {
-        logger.info(`Gestion de la rotation des sauvegardes S3 pour ${userid}.`);
+    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
@@ -5841,6 +5912,8 @@ export async function installPack(packId, user, lang) {
         }
     }
 
+    Event.Trigger("OnPackInstalled", "event", "system", pack);
+
     const modifiedCount = summary.datas.inserted + summary.datas.updated;
     logger.info(`--- Installation of pack '${pack.name}' finished. ---`);
     return { success: errors.length === 0, summary, errors, modifiedCount };