data-primals-engine 1.1.8 → 1.2.0

package/src/modules/data.js

@@ -10,7 +10,7 @@ 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,
@@ -981,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) {
@@ -1233,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}'.`);
@@ -1382,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");
@@ -1396,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();
 
@@ -1527,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;
@@ -1710,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;
@@ -1820,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);
@@ -1845,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{
@@ -1854,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{
@@ -2344,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 ---
@@ -3236,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
             });
         }
@@ -3655,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")};
         }
@@ -3856,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);
@@ -3871,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)
@@ -4071,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) && (
@@ -4610,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() });
 
@@ -4752,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;
@@ -4959,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;
@@ -5073,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
@@ -5357,8 +5383,6 @@ const readKeyFromFile = (user) => {
     return null;
 };
 
-// C:/Dev/data-primals-engine/src/modules/data.js
-
 export const dumpUserData = async (user) => {
     const s3Config = user.configS3;
     const backupDir = getBackupDir();
@@ -5777,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
@@ -5832,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.integration.test.js

@@ -471,7 +471,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const insertResult = await insertData(simpleModel.name, dataToDelete, {}, currentTestUser, false);
             const docId = insertResult.insertedIds[0];
 
-            const deleteResult = await deleteData(simpleModel.name, [docId], {}, currentTestUser, false);
+            const deleteResult = await deleteData(simpleModel.name, [docId], currentTestUser);
 
             expect(deleteResult.success).toBe(true);
             expect(deleteResult.deletedCount).toBe(1);
@@ -493,7 +493,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
                 input: '$name',
                 regex: "^Item Filtrable"
             } };
-            const deleteResult = await deleteData(simpleModel.name, [], filter, currentTestUser, false);
+            const deleteResult = await deleteData(simpleModel.name, filter, currentTestUser);
 
             expect(deleteResult.success).toBe(true);
             expect(deleteResult.deletedCount).toBe(2);
@@ -551,19 +551,16 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         it('devrait trouver un document par une condition sur une relation simple ($find)', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
             const searchParams = {
-                user: currentTestUser,
-                query: {
-                    model: comprehensiveTestModelDefinition.name,
-                    filter: {
-                        relationSingle: {
-                            "$find": { "$and": [{"$eq": ["$$this.relatedValue", 101]}] }
-                        }
-                    },
-                    autoExpand: true,
-                    depth: 8
-                }
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    relationSingle: {
+                        "$find": { "$and": [{"$eq": ["$$this.relatedValue", 101]}] }
+                    }
+                },
+                autoExpand: true,
+                depth: 8
             };
-            const { data, count } = await searchData(searchParams);
+            const { data, count } = await searchData(searchParams, currentTestUser);
             expect(count).toBe(1);
             expect(data).toHaveLength(1);
             expect(data[0]._id.toString()).toBe(docId1.toString());
@@ -575,18 +572,15 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         it('ne devrait pas trouver de document si la condition $find sur relation simple ne correspond pas', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
             const searchParams = {
-                user: currentTestUser,
-                query: {
-                    model: comprehensiveTestModelDefinition.name,
-                    filter: {
-                        relationSingle: {
-                            "$find": { "$eq": ["$$this.relatedName", "NonExistentRelName"] }
-                        }
-                    },
-                    depth: 1
-                }
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    relationSingle: {
+                        "$find": { "$eq": ["$$this.relatedName", "NonExistentRelName"] }
+                    }
+                },
+                depth: 1
             };
-            const { data, count } = await searchData(searchParams);
+            const { data, count } = await searchData(searchParams, currentTestUser);
             expect(count).toBe(0);
             expect(data).toHaveLength(0);
         });
@@ -594,20 +588,17 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         it('devrait trouver des documents par une condition sur une relation multiple ($find)', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
             const searchParams = {
-                user: currentTestUser,
-                query: {
-                    model: comprehensiveTestModelDefinition.name,
-                    filter: {
-                        $and: [{$ne:["$stringRequired", null]}, {
-                            relationMultiple: { // Le champ qui est un tableau de relations
-                                "$find": {"$eq": ["$$this.relatedValue", 102]} // Condition sur les documents liés
-                            }
-                        }]
-                    },
-                    depth: 1
-                }
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    $and: [{$ne:["$stringRequired", null]}, {
+                        relationMultiple: { // Le champ qui est un tableau de relations
+                            "$find": {"$eq": ["$$this.relatedValue", 102]} // Condition sur les documents liés
+                        }
+                    }]
+                },
+                depth: 1
             };
-            const { data, count } = await searchData(searchParams);
+            const { data, count } = await searchData(searchParams, currentTestUser);
             expect(count).toBe(1);
             expect(data).toHaveLength(1);
             expect(data[0]._id.toString()).toBe(docId1.toString());
@@ -620,19 +611,16 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         it('devrait trouver des documents en combinant un filtre normal et un filtre $find', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
             const searchParams = {
-                user: currentTestUser,
-                query: {
-                    model: comprehensiveTestModelDefinition.name,
-                    filter: {
-                        stringRequired: "SearchDoc1", // Filtre sur le modèle principal
-                        relationSingle: {
-                            "$find": {"$gt": ["$$this.relatedValue", 100] } // Filtre sur la relation
-                        }
-                    },
-                    depth: 1
-                }
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    stringRequired: "SearchDoc1", // Filtre sur le modèle principal
+                    relationSingle: {
+                        "$find": {"$gt": ["$$this.relatedValue", 100] } // Filtre sur la relation
+                    }
+                },
+                depth: 1
             };
-            const { data, count } = await searchData(searchParams);
+            const { data, count } = await searchData(searchParams,currentTestUser);
             expect(count).toBe(1);
             expect(data).toHaveLength(1);
             expect(data[0]._id.toString()).toBe(docId1.toString());
@@ -641,26 +629,21 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         it('devrait retourner un tableau vide si $find ne correspond à aucun document lié', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
             const searchParams = {
-                user: currentTestUser,
-                query: {
-                    model: comprehensiveTestModelDefinition.name,
-                    filter: {
-                        relationMultiple: {
-                            "$find": { "$eq": ["$$this.relatedName", "NonExistentRelNameForMultiple"] }
-                        }
-                    },
-                    depth: 1
-                }
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    relationMultiple: {
+                        "$find": { "$eq": ["$$this.relatedName", "NonExistentRelNameForMultiple"] }
+                    }
+                },
+                depth: 1
             };
-            const { data, count } = await searchData(searchParams);
+            const { data, count } = await searchData(searchParams,currentTestUser);
             expect(count).toBe(0);
             expect(data).toHaveLength(0);
         });
 
     });
 
-    // Dans C:/Dev/hackersonline-engine/test/data.integration.test.js
-
     describe('installPack', () => {
         let testPacksColInstance;
 
@@ -824,8 +807,8 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             // Cleanup before starting to ensure a clean state
             await deleteModels({ name: productModel.name, _user: user.username });
             await deleteModels({ name: orderModel.name, _user: user.username });
-            await deleteData(productModel.name, [], {}, user);
-            await deleteData(orderModel.name, [], {}, user);
+            await deleteData(productModel.name, {}, user);
+            await deleteData(orderModel.name, {}, user);
 
             // Create models
             await createModel({ ...productModel, _user: user.username });
@@ -843,8 +826,8 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         afterAll(async () => {
             await deleteModels({ name: productModel.name, _user: user.username });
             await deleteModels({ name: orderModel.name, _user: user.username });
-            await deleteData(productModel.name, [], {}, user);
-            await deleteData(orderModel.name, [], {}, user);
+            await deleteData(productModel.name, {}, user);
+            await deleteData(orderModel.name, {}, user);
         });
 
         it('should ALLOW inserting data with a valid relation', async () => {
@@ -852,7 +835,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(result.success).toBe(true);
             expect(result.insertedIds).toHaveLength(1);
             // Cleanup the created order for test isolation
-            await deleteData(orderModel.name, result.insertedIds, {}, user);
+            await deleteData(orderModel.name, result.insertedIds, user);
         });
 
         it('should REJECT inserting data with a relation that does not respect the filter', async () => {
@@ -873,7 +856,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(result.modifiedCount).toBeGreaterThanOrEqual(0);
 
             // Cleanup
-            await deleteData(orderModel.name, initialOrder.insertedIds, {}, user);
+            await deleteData(orderModel.name, initialOrder.insertedIds, user);
         });
 
         it('should REJECT updating data with a relation that does not respect the filter', async () => {
@@ -885,7 +868,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(result.success).toBe(false);
             expect(result.error).toContain('produit');
             // Cleanup
-            await deleteData(orderModel.name, initialOrder.insertedIds, {}, user);
+            await deleteData(orderModel.name, initialOrder.insertedIds, user);
         });
     });
 });

package/test/workflow.integration.test.js

@@ -299,7 +299,7 @@ describe('Intégration des Workflows - triggerWorkflows', () => {
         }, {}, mockUser, false);
 
         // 2. Act: Supprimer la donnée
-        const deleteResult = await deleteData(targetDataModel.name, [projectId], {}, mockUser, true, true);
+        const deleteResult = await deleteData(targetDataModel.name, [projectId], mockUser, true, true);
         expect(deleteResult.success).toBe(true);
 
         // 3. Assert: Un `workflowRun` doit être créé