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

package/src/modules/data.js

@@ -3,14 +3,14 @@ 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";
 import {randomColor} from "randomcolor";
 import cronstrue from 'cronstrue/i18n.js';
 import { setTimeoutMiddleware } from '../middlewares/timeout.js';
-
+import { mkdir } from 'node:fs/promises';
 import {
     anonymizeText,
     encryptValue,
@@ -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
@@ -980,13 +981,10 @@ async function runStatefulAlertJob(alertId) {
         // 3. Evaluate the trigger condition
         const apiFilter = (alertDoc.triggerCondition);
         const { count } = await searchData({
-            user: { username: alertDoc._user },
-            query: {
-                model: alertDoc.targetModel,
-                filter: apiFilter,
-                limit: 1
-            }
-        });
+            model: alertDoc.targetModel,
+            filter: apiFilter,
+            limit: 1
+        }, { username: alertDoc._user });
 
         // 4. If condition is met, send notification and update state
         if (count > 0) {
@@ -1232,17 +1230,14 @@ export async function handleCustomEndpointRequest(req, res) {
     try {
         // 1. Trouver l'endpoint correspondant dans la base de données
         const endpointSearch = await searchData({
-            user,
-            query: {
-                model: 'endpoint',
-                filter: {
-                    path: path,
-                    method: method,
-                    isActive: true
-                },
-                limit: 1
-            }
-        });
+            model: 'endpoint',
+            filter: {
+                path: path,
+                method: method,
+                isActive: true
+            },
+            limit: 1
+        }, user);
 
         if (endpointSearch.count === 0) {
             logger.warn(`[Endpoint] 404 - No active endpoint found for user '${user.username}', path '${path}', method '${method}'.`);
@@ -1381,6 +1376,9 @@ export async function onInit(defaultEngine) {
         }
 
 
+        // Create the uploads directories
+        await mkdir(path.join("uploads", "tmp"),{ recursive: true});
+
     }else {
         modelsCollection = getCollection("models");
         datasCollection = getCollection("datas");
@@ -1395,7 +1393,7 @@ export async function onInit(defaultEngine) {
     schedule.scheduleJob("0 0 * * *", async () => {
         const dt = new Date();
         dt.setTime(dt.getTime()-1000*3600*24*14);
-        await deleteData("request", [], {"$lt": ["$timestamp",dt.toISOString()]}, null, false);
+        await deleteData("request", {"$lt": ["$timestamp",dt.toISOString()]}, null, false);
     });
     await scheduleWorkflowTriggers();
 
@@ -1526,14 +1524,11 @@ export async function onInit(defaultEngine) {
 
             // On utilise la fonction de recherche interne de l'application
             const searchResult = await searchData({
-                query: {
-                    model,
-                    filter: processedFilter,
-                    limit, // Optimisation : pas besoin de plus de résultats
-                    page: 1
-                },
-                user: user
-            });
+                model,
+                filter: processedFilter,
+                limit, // Optimisation : pas besoin de plus de résultats
+                page: 1
+            }, user);
 
             // searchData devrait renvoyer un `count` total des documents correspondants
             const isCompleted = searchResult.count >= limit;
@@ -1709,6 +1704,48 @@ export async function onInit(defaultEngine) {
     });
 
 
+    engine.post('/api/model/search', [middlewareAuthenticator, userInitiator], async (req, res) => {
+        const { query } = req.fields;
+        const user = req.me;
+
+        if (!query || typeof query !== 'string') {
+            return res.status(400).json({ success: false, error: 'A search query string is required.' });
+        }
+
+        try {
+            // Utilise une expression régulière pour une recherche insensible à la casse
+            const searchRegex = new RegExp(query, 'i');
+
+            const results = await modelsCollection.find({
+                // Cherche dans les modèles de l'utilisateur OU les modèles partagés
+                $or: [
+                    { _user: user.username },
+                    { _user: { $exists: false } }
+                ],
+                // Cherche dans le nom OU la description
+                $and: [
+                    { $or: [
+                        { name: { $regex: searchRegex } },
+                        { description: { $regex: searchRegex } }
+                    ]}
+                ]
+            }, {
+                // On ne retourne que les informations utiles pour l'IA, pas tout le modèle
+                projection: {
+                    name: 1,
+                    description: 1,
+                    _id: 0
+                }
+            }).limit(10).toArray(); // Limite à 10 résultats pour ne pas surcharger
+
+            res.json({ success: true, models: results });
+
+        } catch (error) {
+            logger.error(`[Model Search] Error searching models for query "${query}":`, error);
+            res.status(500).json({ success: false, error: 'An internal server error occurred.' });
+        }
+    });
+
     engine.post('/api/model/generate', [middlewareAuthenticator, userInitiator, assistantGlobalLimiter, generateLimiter, setTimeoutMiddleware(30000)], async (req, res) => {
         // --- NOUVELLE LOGIQUE : Accepter le prompt ET un modèle existant ---
         const { prompt, history = [], existingModel } = req.fields;
@@ -1819,7 +1856,7 @@ export async function onInit(defaultEngine) {
         const { pack } = req.fields;
 
         try {
-            const {data, count} = await searchData({query: {...req.query, model: req.fields.model || req.query.model, filter: req.fields.filter, pack}, user: req.me });
+            const {data, count} = await searchData({...req.query, model: req.fields.model || req.query.model, filter: req.fields.filter, pack}, req.me);
 
             if( req.query.attachment ) {
                 res.attachment(req.query.attachment);
@@ -1844,7 +1881,7 @@ export async function onInit(defaultEngine) {
 
     engine.delete('/api/data/:ids', [throttle, middlewareAuthenticator, userInitiator, middlewareLogger, setTimeoutMiddleware(15000)], async (req, res) => {
         const ids = req.params.ids.split(',');
-        const r = await deleteData(req.fields.model, ids, {}, req.me);
+        const r = await deleteData(req.fields.model, ids, req.me);
         if( r.error) {
             return res.status(r.statusCode || 400).json(r);
         }else{
@@ -1853,7 +1890,7 @@ export async function onInit(defaultEngine) {
     });
 
     engine.delete('/api/data', [throttle, middlewareAuthenticator, userInitiator, middlewareLogger, setTimeoutMiddleware(15000)], async (req, res) => {
-        const r = await deleteData(req.fields.model, [], req.fields.filter, req.me);
+        const r = await deleteData(req.fields.model, req.fields.filter, req.me);
         if( r.error) {
             return res.status(r.statusCode || 400).json(r);
         }else{
@@ -2343,12 +2380,6 @@ export async function onInit(defaultEngine) {
      * }
      * Returns: Array of aggregated data points (e.g., [{ label: '...', value: ... }]) or an error.
      */
-    // Dans server/src/modules/data.js, modifiez la route POST /api/charts/aggregate
-
-    // Dans server/src/modules/data.js, modifiez la route POST /api/charts/aggregate
-    // C:/Dev/hackersonline-engine/server/src/modules/data.js
-
-    // ... (autres imports et code)
 
     engine.post('/api/charts/aggregate', [throttle, middlewareAuthenticator, userInitiator, ...userMiddlewares, setTimeoutMiddleware(15000)], async (req, res) => {
         // --- Récupérer groupByLabelField ---
@@ -3235,13 +3266,10 @@ async function processRelations(docToProcess, model, collection, me, idMap) {
             batchFinds.push({
                 field: field.name,
                 promise: searchData({
-                    user: me,
-                    query: {
-                        filter: value.$find,
-                        limit: field.multiple ? 0 : 1,
-                        model: field.relation
-                    }
-                }),
+                    filter: value.$find,
+                    limit: field.multiple ? 0 : 1,
+                    model: field.relation
+                }, me),
                 multiple: field.multiple
             });
         }
@@ -3654,7 +3682,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
         }
 
         // 2. Récupération des documents existants et de leur hash original
-        const existingDocs = (await searchData({user, query: {model: modelName, filter}}))?.data;
+        const existingDocs = (await searchData({model: modelName, filter}, user))?.data;
         if (!existingDocs || existingDocs.length === 0) {
             return {success: false, error: i18n.t("api.data.notFound")};
         }
@@ -3855,7 +3883,8 @@ async function handleScheduledJobs(modelName, existingDocs, collection, updateDa
     }
 }
 
-export const deleteData = async (modelName, ids = [], filter, user ={}, triggerWorkflow, waitForWorkflow = false) => {
+
+export const deleteData = async (modelName, filter, user ={}, triggerWorkflow, waitForWorkflow = false) => {
 
     try {
         const collection = await getCollectionForUser(user);
@@ -3870,8 +3899,8 @@ export const deleteData = async (modelName, ids = [], filter, user ={}, triggerW
             });
 
         // Ajouter le filtre par IDs si fourni
-        if (ids && ids.length > 0) {
-            findFilter.push({"$in": ["$_id", ids.map(m => new ObjectId(m))]});
+        if (Array.isArray(filter) && filter.length > 0) {
+            findFilter.push({"$in": ["$_id", filter.map(m => new ObjectId(m))]});
         }
 
         // Ajouter le filtre par nom de modèle si fourni (utile si 'filter' est utilisé seul)
@@ -4070,7 +4099,7 @@ export const deleteData = async (modelName, ids = [], filter, user ={}, triggerW
 
 // ... (le reste du fichier data.js)
 
-export const searchData = async ({user, query}) => {
+export const searchData = async (query, user) => {
     const { page, limit, sort, model, ids, timeout, pack } = query; // Les filtres de la requête (attention aux injections MongoDB !)
 
     if( user.username !== 'demo' && isLocalUser(user) && (
@@ -4609,8 +4638,10 @@ export const importData = async(options, files, user) => {
             // let allProcessedData = [];
             // let modelNameForImport = '';
             // --- FIN DE LA MODIFICATION ---
-
-            if (file.mimetype === 'application/json' || file.originalFilename.endsWith('.json')) {
+            if( !file.name ){
+                throw new Error("No file provided.");
+            }
+            if (file.type === 'application/json' || file.name.endsWith('.json')) {
                 fileProcessed = true;
                 const jsonData = await runImportExportWorker('parse-json', { fileContent: fileContent.toString() });
 
@@ -4751,7 +4782,7 @@ export const importData = async(options, files, user) => {
                 }
                 // --- FIN DE LA MODIFICATION PRINCIPALE ---
 
-            } else if (file.mimetype === 'text/csv' || file.originalFilename.endsWith('.csv')) {
+            } else if (file.type === 'text/csv' || file.name.endsWith('.csv')) {
                 // --- Logique CSV (inchangée, mais maintenant elle est séparée de la logique JSON) ---
                 fileProcessed = true;
                 const modelNameForImport = options.model;
@@ -4958,16 +4989,13 @@ export const exportData= async (options, user) =>{
 
             // --- Fetch Data using searchData ---
             const searchParams = {
-                user: user,
-                query: {
-                    model: modelName,
-                    filter: modelSpecificFilter,
-                    depth: parsedDepth,
-                    limit: remainingLimit
-                }
+                model: modelName,
+                filter: modelSpecificFilter,
+                depth: parsedDepth,
+                limit: remainingLimit
             };
 
-            const { data: resultData, count } = await searchData(searchParams);
+            const { data: resultData, count } = await searchData(searchParams, user);
 
             if (resultData && resultData.length > 0) {
                 exportResults[modelName] = resultData;
@@ -5072,7 +5100,6 @@ function isValidAggregationOperator(operator) {
 
     return [...arithmeticOperators, ...comparisonOperators, ...stringOperators, ...conditionalOperators].includes(operator);
 }
-// C:/Dev/hackersonline-engine/server/src/modules/data.js
 
 /**
  * Gère les traductions spécifiques à l'utilisateur et traite les données de manière récursive
@@ -5217,6 +5244,7 @@ const handleFields = async (model, data, user, isRecursiveCall = false) => {
     }
 };
 
+let restoreRequests = {};
 export const validateRestoreRequest = (username, token) => {
     const request = restoreRequests[username];
     if (!request) {
@@ -5247,20 +5275,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 +5326,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();
@@ -5347,120 +5384,87 @@ const readKeyFromFile = (user) => {
 };
 
 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
@@ -5797,7 +5801,7 @@ export async function installPack(packId, user, lang) {
                 const finalSelector = { ...linkSelector };
                 delete finalSelector['_model']; // nécessaire
                 // CORRECTION 4: Appel corrigé à searchData
-                const { data: targetDocs } = await searchData({ user, query: { model: targetModelName, filter: finalSelector } });
+                const { data: targetDocs } = await searchData({model: targetModelName, filter: finalSelector }, user);
 
                 if (targetDocs && targetDocs.length > 0) {
                     targetIds = targetDocs.map(d => d._id); // Récupère un tableau d'ObjectIds
@@ -5852,11 +5856,6 @@ export const installAllPacks = async () => {
     await packsCollection.insertMany(packs);
 }
 
-// Dans C:/Dev/data-primals-engine/src/modules/data.js
-// Dans C:/Dev/data-primals-engine/src/modules/data.js
-
-// ... (imports inchangés)
-
 export async function handleDemoInitialization(req, res) {
     const user = req.me;
     const body = req.fields;

package/src/modules/workflow.js

@@ -197,15 +197,15 @@ export async function executeSafeJavascript(actionDef, context, user) {
         await jail.set('db', createJailFunction({
             create: (modelName, dataObject) => insertData(modelName, dataObject, {}, user),
             find: async (modelName, filter) => {
-                const result = await searchData({ user, query: { model: modelName, filter } });
+                const result = await searchData({ model: modelName, filter }, user);
                 return new ivm.ExternalCopy(result.data).copyInto();
             },
             findOne: async (modelName, filter) => {
-                const result = await searchData({ user, query: { model: modelName, filter, limit: 1 } });
+                const result = await searchData({ model: modelName, filter, limit: 1 }, user);
                 return new ivm.ExternalCopy(result.data?.[0] || null).copyInto();
             },
             update: (modelName, filter, updateObject) => patchData(modelName, filter, updateObject, {}, user),
-            delete: (modelName, filter) => deleteData(modelName, null, filter, user)
+            delete: (modelName, filter) => deleteData(modelName, filter, user)
         }));
 
         const createLoggerFunction = (level) => {
@@ -228,11 +228,11 @@ export async function executeSafeJavascript(actionDef, context, user) {
         await jail.set('env', createJailFunction({
             get: async (variableName) => {
                 if (!variableName) return null;
-                const result = await searchData({ user, query: { model: 'env', filter: { name: variableName }, limit: 1 } });
+                const result = await searchData({ model: 'env', filter: { name: variableName }, limit: 1 }, user);
                 return new ivm.ExternalCopy(result.data?.[0]?.value || null).copyInto();
             },
             getAll: async () => {
-                const result = await searchData({ user, query: { model: 'env' } });
+                const result = await searchData({ model: 'env' }, user);
                 const envObject = result.data.reduce((acc, v) => {
                     acc[v.name] = v.value;
                     return acc;
@@ -708,7 +708,7 @@ async function handleDeleteDataAction(actionDef, contextData, user, dbCollection
         // 5. Call the centralized deleteData function (à créer dans data.js)
         // Cette fonction devra gérer la recherche préalable pour les workflows 'DataDeleted' et la suppression des fichiers.
         const deleteResult = await deleteData(
-            targetModel, [],
+            targetModel,
             selectorObject,
             user
         );
@@ -1115,7 +1115,7 @@ export async function triggerWorkflows(triggerData, user, eventType)  {
 
                         // Exécuter la vérification dans la base de données
                         // Utilisation de countDocuments pour une vérification rapide
-                        const matchCount = await searchData({ user, query: { model: targetModelName, filter: finalFilter, limit: 1 } });
+                        const matchCount = await searchData({  model: targetModelName, filter: finalFilter, limit: 1 }, user);
 
                         if (!matchCount.count) {
                             console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter non satisfait par la donnée ${dataId}. WorkflowRun non créé.`);
@@ -1198,7 +1198,6 @@ export async function triggerWorkflows(triggerData, user, eventType)  {
  * @param {object} user - The user context for database access.
  * @returns {Promise<void>}
  */
-// C:/Dev/hackersonline-engine/server/src/modules/workflow.js
 
 export async function processWorkflowRun(workflowRunId, user) {
     const dbCollection = await getCollectionForUser(user);
@@ -1280,7 +1279,7 @@ export async function processWorkflowRun(workflowRunId, user) {
             try {
                 // --- 7. Évaluation des conditions de l'étape ---
                 if (currentStepDef.conditions && Object.keys(currentStepDef.conditions).length > 0) {
-                    const searchResult = await searchData({ user, query: { model: contextData.triggerDataModel, filter: currentStepDef.conditions, limit: 1 } });
+                    const searchResult = await searchData({ model: contextData.triggerDataModel, filter: currentStepDef.conditions, limit: 1}, user);
                     conditionsMet = searchResult && searchResult.count > 0;
                     logger.info(`[processWorkflowRun] Run ID: ${runId}, Step ID: ${currentStepId}: Conditions evaluated. Found ${searchResult ? searchResult.count : 0} match(es). Result: ${conditionsMet}`);
                 }
@@ -1478,9 +1477,8 @@ async function handleSendEmailAction(action, triggerData, user) {
 
     // 1. Récupérer la configuration SMTP depuis le modèle 'env' de l'utilisateur
     const envVars = await searchData({
-        user,
-        query: { model: 'env', limit: 100 } // Limite raisonnable pour les variables d'env
-    });
+        model: 'env', limit: 100 } // Limite raisonnable pour les variables d'env
+    , user);
 
     if (!envVars.data || envVars.data.length === 0) {
         throw new Error("Aucune variable d'environnement (modèle 'env') trouvée pour la configuration SMTP.");

package/src/providers.js

@@ -91,7 +91,7 @@ export class UserProvider {
     }
 
     async hasFeature(user, feature) {
-        return this.plans[user.userPlan]?.features.some(f => f === feature);
+        return this.plans[user?.userPlan]?.features.some(f => f === feature);
     }
 
     // Ajoutez ici d'autres méthodes nécessaires : findUserById, createUser, etc.

package/src/workers/crypto-worker.js

@@ -1,4 +1,3 @@
-// C:/Dev/hackersonline-engine/server/src/workers/crypto-worker.js
 import { parentPort } from 'worker_threads';
 import crypto from 'node:crypto';
 import fs from 'node:fs/promises';

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
 });