data-primals-engine 1.1.8-rc.1 → 1.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-primals-engine",
-  "version": "1.1.8-rc.1",
+  "version": "1.1.8",
   "description": "data-primals-engine is the package responsible from handling large amount of data in a practical and performant way. It can handle large amount of data in a practical and performant way. It can also get workflow models working (for automation), and fully supports internationalisation.",
   "main": "src/engine.js",
   "type": "module",
@@ -43,9 +43,9 @@
     "./*": "./src/*.js"
   },
   "peerDependencies": {
+    "express": "^5.1.0",
     "react": ">=18.0.0",
-    "react-query": ">=3.0.0",
-    "express": "^5.1.0"
+    "react-query": ">=3.0.0"
   },
   "dependencies": {
     "@langchain/core": "^0.3.66",
@@ -69,6 +69,7 @@
     "express-rate-limit": "^8.0.1",
     "express-session": "^1.18.2",
     "i18next-browser-languagedetector": "^8.2.0",
+    "isolated-vm": "^4.7.2",
     "juice": "^11.0.1",
     "mathjs": "^14.6.0",
     "mongodb": "^6.18.0",
@@ -88,7 +89,6 @@
     "tar": "^7.4.3",
     "uniqid": "^5.4.0",
     "vitest": "^3.2.4",
-    "isolated-vm": "^4.7.2",
     "yaml": "^2.8.0"
   },
   "devDependencies": {

package/src/core.js

@@ -340,12 +340,13 @@ export const event_off = (name, callback) => {
 };
 
 
-export function slugify(str) {
+export function slugify(str,replacer='-', replaceUnicode=false) {
     str = str.replace(/^\s+|\s+$/g, ''); // trim leading/trailing white space
     str = str.toLowerCase(); // convert string to lowercase
-    str = str.replace(/[^a-z0-9 -]/g, '') // remove any non-alphanumeric characters
-        .replace(/\s+/g, '-') // replace spaces with hyphens
-        .replace(/-+/g, '-'); // remove consecutive hyphens
+    if( replaceUnicode)
+        str = str.replace(/[^a-z0-9 -]/g, ''); // remove any non-alphanumeric characters
+    str = str.replace(/\s+/g, replacer) // replace spaces with hyphens
+        .replace(/-+/g, replacer); // remove consecutive hyphens
     return str;
 }
 
@@ -388,4 +389,8 @@ export function object_equals( x, y ) {
     // allows x[ p ] to be set to undefined
 
     return true;
-}
+}
+
+export const isValidPath = (path) =>{
+    return /^(?:[a-z]:)?[\/\\]{0,2}(?:[.\/\\ ](?![.\/\\\n])|[^<>:"|?*.\/\\ \n])+$/gmi.test(path);
+}

package/src/modules/data.js

@@ -3,7 +3,7 @@ import {BSON, ObjectId} from "mongodb";
 import * as util from 'node:util';
 import {promisify} from 'node:util';
 import crypto from "node:crypto";
-import {exec} 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";
@@ -105,6 +105,7 @@ const delay = ms => new Promise(res => setTimeout(res, ms));
 
 const getBackupDir = () => process.env.BACKUP_DIR || './backups'; // Répertoire de stockage des sauvegardes
 const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 
 let importJobs = {};
 const IMPORT_CHUNK_SIZE = 100; // Nombre d'enregistrements à traiter par lot
@@ -5217,6 +5218,7 @@ const handleFields = async (model, data, user, isRecursiveCall = false) => {
     }
 };
 
+let restoreRequests = {};
 export const validateRestoreRequest = (username, token) => {
     const request = restoreRequests[username];
     if (!request) {
@@ -5247,20 +5249,21 @@ export const loadFromDump = async (user, options = {}) => {
         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 backupDir = getBackupDir();
-    const backupFilenameRegex = new RegExp(`^backup_${user.username}_(\\d+)\\.tar\\.gz$`);
+    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 ---
 
-    const tmpRestoreDir = path.join(backupDir, `tmp_restore_${user.username}_${Date.now()}`);
+    const tmpRestoreDir = path.join(backupDir, `tmp_restore_${userId}_${Date.now()}`);
 
     try {
         await runCryptoWorkerTask('decrypt', { filePath: backupFilePath, password: encryptedKey });
@@ -5297,17 +5300,25 @@ export const loadFromDump = async (user, options = {}) => {
         }
 
         let command;
+        const args = [
+            '--uri', dbUrl,
+            '--db', dbName
+        ];
+
         if (modelsOnly) {
-            // Restaure uniquement la collection des modèles
-            command = `mongorestore --uri="${dbUrl}" --db=${dbName} --nsInclude="${dbName}.models" "${restoreSourceDir}"`;
+            args.push('--nsInclude', `${dbName}.models`);
         } else {
-            // Restauration complète
-            command = `mongorestore --uri="${dbUrl}" --db=${dbName} --nsInclude="${dbName}.datas" --nsInclude="${dbName}.models" "${restoreSourceDir}"`;
+            // 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 execAsync(command);
 
+        logger.info(`[${action}] Executing restore command: ${command}`);
+        await execFileAsync('mongorestore', args);
+        
         // --- Tâches Post-Restauration ---
         await scheduleAlerts();
         await scheduleWorkflowTriggers();
@@ -5346,121 +5357,90 @@ const readKeyFromFile = (user) => {
     return null;
 };
 
+// C:/Dev/data-primals-engine/src/modules/data.js
+
 export const dumpUserData = async (user) => {
-// Déterminer la clé de chiffrement
-    // Pour cet exemple, on simule la config S3. Remplace par la vraie récupération.
-    const s3Config = user.configS3; // Supposons que l'objet 'user' passé contient déjà 'configS3'
+    const s3Config = user.configS3;
     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);
-        logger.info('Encryption key générée.');
-    } else {
-        logger.info('Encryption key chargée.');
     }
 
     try {
-        // Déterminer la fréquence de la sauvegarde
         const backupFrequency = await engine.userProvider.getBackupFrequency(user);
-
         logger.info(`Fréquence de sauvegarde : ${backupFrequency}.`);
 
-        // Définir le nom du fichier de sauvegarde et les chemins
-        const backupFilename = `backup_${user.username}`; //nom corrigé
-        const backupFileBasePath = path.join(backupDir, backupFilename); //chemin corrigé
-        const backupFilePath = `${backupFileBasePath}_${Date.now()}`;
-        const backupFilenameBase = `backup_${user.username}`;
-        const timestamp = Date.now();
-        const localTempDumpDir = path.join(backupDir, `${backupFilenameBase}_${timestamp}_temp`); // Répertoire temporaire local
-        const finalArchiveName = `${backupFilenameBase}_${timestamp}.tar.gz`; // Nom de l'archive finale
-        const localArchivePath = path.join(backupDir, finalArchiveName); // Chemin
-
-        logger.info(`Chemin du fichier de sauvegarde : ${backupFilePath}.`);
-
-        // Ajoute les filtres sur les collections et l'utilisateur
         const collections = await MongoDatabase.listCollections().toArray();
-        let query;
-        let col;
         for (const collection of collections) {
-
-            const colls = [await getUserCollectionName(user), 'models'];
-            if( colls.includes(collection.name) ){
-
-                // Exécuter mongodump avec les filtres appropriés
-                let command = `mongodump --uri="${dbUrl}" --db=${dbName} --out=${localTempDumpDir} `;
-
-                query = JSON.stringify({_user : user.username }); // Filtrer par _user
-                col = ` --collection=${collection.name}`;
-                command += `${col} --query ${JSON.stringify(query)}`;
-
-                logger.info(`Exécution de la commande : ${command}`);
-                await execAsync(command);
+            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);
             }
-
         }
 
-
-        // Zipper le contenu du répertoire de dump temporaire
-        // Le répertoire zippé sera `localTempDumpDir/${dbName}` si mongodump a créé ce sous-dossier
-        const dumpSourceDir = path.join(localTempDumpDir, dbName); // Le répertoire que mongodump a créé
+        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 {
-            throw new Error(`Le répertoire de dump ${dumpSourceDir} n'a pas été trouvé après mongodump.`);
+            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
+            return Promise.resolve();
         }
 
-        // Chiffrer le fichier local avant l'upload si tu le souhaites (optionnel si le bucket S3 est déjà chiffré)
-        await encryptFile(localArchivePath, encryptedKey); // Ta fonction existante
+        await encryptFile(localArchivePath, encryptedKey);
 
         if (s3Config && s3Config.bucketName) {
-            logger.info(`Téléversement de la sauvegarde vers S3 pour l'utilisateur ${user.username}. Bucket: ${s3Config.bucketName}`);
             await uploadToS3(s3Config, localArchivePath, finalArchiveName);
-            logger.info(`Sauvegarde téléversée avec succès vers S3 pour ${user.username}.`);
-            // Optionnel: supprimer l'archive locale après l'upload S3 réussi
-            fs.unlinkSync(localArchivePath);
-            logger.info(`Archive locale ${localArchivePath} supprimée après l'upload S3.`);
+            fs.unlinkSync(localArchivePath); // Supprime l'archive locale après l'upload
         } else {
-            logger.info(`Aucune configuration S3 trouvée pour ${user.username}. La sauvegarde reste locale : ${localArchivePath}.`);
-            // Si pas de S3, le fichier chiffré localement (si encryptFile a été appelé) reste.
-            // Si tu ne chiffres pas localement et pas de S3, c'est l'archive .tar.gz qui reste.
-        }
-
-        // Supprimer le répertoire de dump temporaire
-        if (fs.existsSync(localTempDumpDir)) {
-            fs.rmSync(localTempDumpDir, { recursive: true, force: true });
-            logger.info(`Répertoire de dump temporaire ${localTempDumpDir} supprimé.`);
+            logger.info(`Aucune configuration S3 trouvée. La sauvegarde reste locale : ${localArchivePath}.`);
         }
 
         logger.info(`Sauvegarde réussie pour l'utilisateur ${user.username}.`);
-        // La gestion de la rotation des sauvegardes devra être adaptée
-        // si les sauvegardes sont sur S3 (lister depuis S3, supprimer depuis S3).
-        await manageBackupRotation(user, backupFrequency, s3Config); // Passer s3Config
+        await manageBackupRotation(user, backupFrequency, s3Config);
 
-        return Promise.resolve();
     } catch (error) {
         logger.error(`Erreur lors de la sauvegarde pour l'utilisateur ${user.username}:`, error);
-        // Nettoyage en cas d'erreur
-        const localTempDumpDir = path.join(backupDir, `backup_${user.username}_${Date.now()}_temp`); // Recalculer pour être sûr
-        if (fs.existsSync(localTempDumpDir)) {
-            fs.rmSync(localTempDumpDir, { recursive: true, force: true });
-        }
-        const localArchivePath = path.join(backupDir, `backup_${user.username}_${Date.now()}.tar.gz`); // Recalculer
+        // 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
+        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 = user.username; // ou user._id selon ce que tu utilises dans les noms de fichiers
-
+    const userId = getObjectHash({user:user.username});
     let filesToManage = [];
 
     if (s3Config && s3Config.bucketName) {
-        logger.info(`Gestion de la rotation des sauvegardes S3 pour ${userId}.`);
+        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

package/test/data.backup.integration.test.js

@@ -86,7 +86,7 @@ afterAll(async () => {
         fs.readdirSync(backupDir).forEach(file => {
             fs.unlinkSync(path.join(backupDir, file));
         });
-        // Optional: fs.rmdirSync(backupDir); // Remove the directory itself
+        fs.rmdirSync(backupDir); // Remove the directory itself
     }
 });
 
@@ -132,5 +132,7 @@ describe('Data Backup and Restore Integration', () => {
         expect(docAfterRestore.testField).toBe('Initial Value');
         expect(docAfterRestore.optionalField).toBe(123);
 
+        console.log("Tests passed for backup and restore");
+
     }, 15000); // Timeout augmenté pour les opérations de fichiers
 });