data-primals-engine 1.0.11 → 1.1.1

package/src/packs.js

@@ -135,21 +135,20 @@ export const getAllPacks = async () => {
                         }
                     ],
                     "dashboard":  [{
-                            name: "Business Overview",
-                            description: "Displays the total revenue, total orders, and average order value of the store.",
-                            layout: [{
-                                "name": "Store Overview",
-                                "kpis": ["Total Orders", "Average Order Value", "Total Revenue"],
-                                "chartConfigs": [],
-                                "flexViews": []
-                            }],
-                            settings: {
-                                "defaultTimeRange": "last_7_days",
-                                "refreshInterval": null
-                            }
+                        name: "Business Overview",
+                        description: "Displays the total revenue, total orders, and average order value of the store.",
+                        layout: [{
+                            "name": "Store Overview",
+                            "kpis": ["Total Orders", "Average Order Value", "Total Revenue"],
+                            "chartConfigs": [],
+                            "flexViews": []
+                        }],
+                        settings: {
+                            "defaultTimeRange": "last_7_days",
+                            "refreshInterval": null
                         }
-                    ],
-                "order": [
+                    }],
+                    "order": [
                         {
                             "orderId": "ORDER-0001",
                             "orderDate": "2023-10-27T10:00:00Z",
@@ -275,13 +274,13 @@ export const getAllPacks = async () => {
                             "name": "Validate Order",
                             "workflow": { "$link": { "name": "Order Fulfillment", "_model": "workflow" } },
                             "actions": { "$link": { "name": "Update order status to 'processing'", "_model": "workflowAction" } },
-                            "onSuccessStep": { "$link": { "name": "Prepare Shipment", "_model": "workflowStep" } },
+                            "onSuccessStep": { "$link": { "name": "Prepare Shipment", "_model": "workflowStep" } }
                         },
                         {
                             "name": "Prepare Shipment",
                             "workflow": { "$link": { "name": "Order Fulfillment", "_model": "workflow" }},
                             "actions": { "$link": { "name": "Create Shipment Record", "_model": "workflowAction" } },
-                            "onSuccessStep": { "$link": { "name": "Ship Order", "_model": "workflowStep" } },
+                            "onSuccessStep": { "$link": { "name": "Ship Order", "_model": "workflowStep" } }
                         },
                         {
                             "name": "Send Shipment Email Step",
@@ -296,7 +295,7 @@ export const getAllPacks = async () => {
                                 "$link": {
                                     "$or": [
                                         { "$eq": ["$name", "Update order status to 'shipped'"]},
-                                        { "$eq": ["$name", "Send Shipping Confirmation"]},
+                                        { "$eq": ["$name", "Send Shipping Confirmation"]}
                                     ],
                                     "_model": "workflowAction"
                                 }
@@ -374,17 +373,17 @@ export const getAllPacks = async () => {
                             type: 'category',
                             parent: {
                                 "$find": {
-                                    "name": "Website",
+                                    "name": "Website"
                                 }
                             }
                         })), ...tags.map(t =>({
                         name: t,
-                        type: 'keyword',
+                        type: 'keyword'
                     }))],
                     "permission": getPerms(['website', 'taxonomy', 'lang', 'user', 'role', 'permission']).map(m => {
                         return {
                             name: m,
-                            description: '',
+                            description: ''
                         }
                     }),
                     "role": roles.map(m => {
@@ -399,8 +398,8 @@ export const getAllPacks = async () => {
                     }),
                     "channel": [
                         { "name": "Visitor alerts", "type": "web", "description": "Visitor main channel informations" },
-                        { "name": "Newsletter", "type": "email", "description": "Newsletter channel" },
-                    ],
+                        { "name": "Newsletter", "type": "email", "description": "Newsletter channel" }
+                    ]
                 },
                 "fr": {
                     "lang": [{
@@ -408,8 +407,8 @@ export const getAllPacks = async () => {
                         "code": "fr"
                     }],
                     "translation": [
-                        { "lang": { "$find": { "$eq": ["$code", "fr"]}}, "key": "Visitor alerts", "value": "Alertes visiteurs" },
-                    ],
+                        { "lang": { "$find": { "$eq": ["$code", "fr"]}}, "key": "Visitor alerts", "value": "Alertes visiteurs" }
+                    ]
                 }
             }
         },
@@ -548,7 +547,7 @@ export const getAllPacks = async () => {
                         { "lang": { "$link": { "code": "fr", "_model": "lang" } }, "key": "model_description_deal", "value": "Représente une opportunité commerciale avec un contact ou une entreprise." },
 
                         { "lang": { "$link": { "code": "fr", "_model": "lang" } }, "key": "model_interaction", "value": "Interactions" },
-                        { "lang": { "$link": { "code": "fr", "_model": "lang" } }, "key": "model_description_interaction", "value": "Représente une interaction (appel, email, rdv) avec un contact ou une entreprise." },
+                        { "lang": { "$link": { "code": "fr", "_model": "lang" } }, "key": "model_description_interaction", "value": "Représente une interaction (appel, email, rdv) avec un contact ou une entreprise." }
                     ]
                 },
                 "en": {
@@ -595,7 +594,7 @@ export const getAllPacks = async () => {
                         { "lang": { "$link": { "code": "en", "_model": "lang" } }, "key": "model_description_deal", "value": "Represents a business opportunity with a contact or company." },
 
                         { "lang": { "$link": { "code": "en", "_model": "lang" } }, "key": "model_interaction", "value": "Interactions" },
-                        { "lang": { "$link": { "code": "en", "_model": "lang" } }, "key": "model_description_interaction", "value": "Represents an interaction (call, email, meeting) with a contact or company." },
+                        { "lang": { "$link": { "code": "en", "_model": "lang" } }, "key": "model_description_interaction", "value": "Represents an interaction (call, email, meeting) with a contact or company." }
                     ]
                 },
                 "it": {
@@ -1075,14 +1074,14 @@ export const getAllPacks = async () => {
                             "type": "GenerateAIContent",
                             "aiProvider": "OpenAI",
                             "aiModel": "gpt-4o-mini",
-                            "prompt": "Write a short, SEO-optimized product description (approximately 30-40 words) for the following product: '{triggerData.name}'. The description should be engaging and highlight the product. Return only the description text, without an introduction or conclusion.",
+                            "prompt": "Write a short, SEO-optimized product description (approximately 30-40 words) for the following product: '{triggerData.name}'. The description should be engaging and highlight the product. Return only the description text, without an introduction or conclusion."
                         },
                         {
                             "name": "Generate SEO Description from Product (Google API)",
                             "type": "GenerateAIContent",
                             "aiProvider": "Google",
                             "aiModel": "gemini-2.0-flash",
-                            "prompt": "Write a short, SEO-optimized product description (approximately 30-40 words) for the following product: '{triggerData.name}'. The description should be engaging and highlight the product. Return only the description text, without an introduction or conclusion.",
+                            "prompt": "Write a short, SEO-optimized product description (approximately 30-40 words) for the following product: '{triggerData.name}'. The description should be engaging and highlight the product. Return only the description text, without an introduction or conclusion."
                         },
                         {
                             "name": "Update Product with AI Description",
@@ -1100,7 +1099,7 @@ export const getAllPacks = async () => {
                                 "$find": {
                                     $or: [
                                         {"$eq": ["$name", "Generate SEO Description from Product (OpenAI API)"]},
-                                        {"$eq": ["$name", "Update Product with AI Description"]},
+                                        {"$eq": ["$name", "Update Product with AI Description"]}
                                     ]
                                 }
                             },
@@ -2300,7 +2299,7 @@ export const getAllPacks = async () => {
                         { name:"Nouveau manat turkmène",code:"TMT", symbol: "m" },
                         { name:"Som ouzbek",code:"UZS", symbol: "som" },
                         { name:"Dong vietnamien",code:"VND", symbol: "₫" }
-                    ],
+                    ]
                 },
                 "fr":{
                     "lang": [{
@@ -3807,7 +3806,7 @@ export const getAllPacks = async () => {
                         { "lang": { "$link": { "code": "sv", "_model": "lang" } }, "key": "Som ouzbek", "value": "Uzbekisk sum" },
                         { "lang": { "$link": { "code": "sv", "_model": "lang" } }, "key": "Dong vietnamien", "value": "Vietnamesisk dong" }
                     ]
-                },
+                }
 
             }
         }

package/src/providers.js

@@ -1,4 +1,5 @@
 import {compare} from "bcrypt";
+import {maxTotalPrivateFilesSize} from "./constants.js";
 
 /**
  * @class UserProvider
@@ -6,11 +7,15 @@ import {compare} from "bcrypt";
  * C'est une classe de base abstraite, elle n'est pas destinée à être utilisée directement.
  */
 export class UserProvider {
+
+    plans = {};
+
     constructor(engine) {
         if (this.constructor === UserProvider) {
             throw new Error("Abstract classes can't be instantiated.");
         }
         this.engine = engine;
+        this.plans = this.getUserPlans();
     }
 
     /**
@@ -50,6 +55,45 @@ export class UserProvider {
         throw new Error("Method 'initiateUser()' must be implemented.");
     }
 
+    /**
+     * Récupère la limite de stockage d'un utilisateur.
+     * @param user
+     * @returns {Promise<number>}
+     */
+    async getUserStorageLimit(user) {
+        return maxTotalPrivateFilesSize;
+    }
+
+    /**
+     * Récupère la fréquence de sauvegarde d'un utilisateur.
+     * @param user
+     * @returns {Promise<void>}
+     */
+    async getBackupFrequency(user){
+        return 'daily';
+    }
+
+    /**
+     * Récupère les middlewares d'un utilisateur.
+     * @returns {Promise<*[]>}
+     */
+    async getMiddlewares(){
+        return [];
+    }
+
+    getUserPlans(){
+        return {
+            free: {
+                requestLimitPerHour: 10000,
+                features: ['indexes'] // Feature list : indexes is the only option for now. Use a dedicated collection for this user
+            }
+        };
+    }
+
+    async hasFeature(user, feature) {
+        return this.plans[user.userPlan]?.features.some(f => f === feature);
+    }
+
     // Ajoutez ici d'autres méthodes nécessaires : findUserById, createUser, etc.
 }
 
@@ -58,19 +102,73 @@ export class DefaultUserProvider extends UserProvider {
 
     users= [{ username: "demo", password: "demo" }];
 
+    /**
+     * Trouve un utilisateur. Gère spécifiquement les utilisateurs de démo.
+     */
     async findUserByUsername(username) {
+        // Si le nom d'utilisateur commence par "demo", on le considère comme un utilisateur de démo valide et volatile.
+        if (typeof username === 'string' && username.startsWith('demo')) {
+            // On retourne un objet utilisateur de démo avec la structure attendue.
+            return { username: username, password: "demo", userPlan: 'free' }; // Ajout de userPlan pour la cohérence
+        }
+        // Logique pour les vrais utilisateurs (si vous en ajoutez plus tard)
         return this.users.find(user => user.username === username);
     }
 
+    async getUserStorageLimit(user) {
+        return maxTotalPrivateFilesSize;
+    }
+
+    async getBackupFrequency(user){
+        return 'daily';
+    }
+
+    async getMiddlewares(){
+        return []
+    }
+
     async validatePassword(user, password) {
-        return true;
+        // Pour un utilisateur de démo, le mot de passe est toujours valide.
+        if (user.username.startsWith('demo')) {
+            return true;
+        }
+        // Logique pour les vrais utilisateurs
+        return true; // ou votre logique de comparaison bcrypt
     }
 
     async updateUser(user, data) {
         this.users = this.users.map(user => user.username === user.username ? {...user, ...data} : user);
     }
-
+    /**
+     * Initialise l'utilisateur sur la requête. C'est ici que la magie opère.
+     */
     async initiateUser(req) {
-        req.me = this.users[0];
+        // Priorité 1: Un utilisateur est déjà authentifié via une session (pour les vrais comptes).
+        if (req.session?.user?.username) {
+            const user = await this.findUserByUsername(req.session.user.username);
+            if (user) {
+                req.me = user;
+                return; // L'utilisateur est trouvé, on s'arrête là.
+            }
+        }
+
+        // Priorité 2: PasF de session, mais on vérifie la présence d'un cookie "username" pour la démo.
+        const demoUsername = req.cookies?.username;
+        if (demoUsername && typeof demoUsername === 'string' && demoUsername.startsWith('demo')) {
+            // On a trouvé un cookie de démo. On crée l'objet utilisateur correspondant.
+            const demoUser = await this.findUserByUsername(demoUsername);
+            if (demoUser) {
+                req.me = demoUser;
+                return;
+            }
+        }
+    }
+
+    getUserPlans(){
+        return {
+            free: {
+                features: ['indexes']
+            }
+        }
     }
 }

package/src/setenv.js

@@ -2,7 +2,7 @@ import {getRandom} from "data-primals-engine/core";
 import process from "node:process";
 import {Engine} from "./index.js";
 
-let ports = [], engineInstance, mongod;
+let ports = [], engineInstance;
 export const getUniquePort = () =>{
     let d, it=0;
     do{

package/src/user.js

@@ -1,17 +0,0 @@
-import {
-    maxTotalPrivateFilesSizeFree,
-    maxTotalPrivateFilesSizePremium,
-    maxTotalPrivateFilesSizeStandard
-} from "./constants.js";
-
-export const getUserStorageLimit = (user) => {
-    switch (user.userPlan) {
-        case 'premium':
-            return maxTotalPrivateFilesSizePremium;
-        case 'standard':
-            return maxTotalPrivateFilesSizeStandard;
-        case 'free':
-        default:
-            return maxTotalPrivateFilesSizeFree;
-    }
-};

package/src/workers/crypto-worker.js

@@ -46,29 +46,30 @@ parentPort.on('message', async ({ action, payload }) => {
     try {
         let result;
         switch (action) {
-            case 'encrypt':
-                console.log(`[Worker] Received action: ${action} for file: ${payload.filePath}`);
-                await encryptFile(payload.filePath, payload.password);
-                parentPort.postMessage({ success: true }); // Pas de données à retourner
-                break;
+        case 'encrypt':
+            console.log(`[Worker] Received action: ${action} for file: ${payload.filePath}`);
+            await encryptFile(payload.filePath, payload.password);
+            parentPort.postMessage({ success: true }); // Pas de données à retourner
+            break;
 
-            case 'decrypt':
-                console.log(`[Worker] Received action: ${action} for file: ${payload.filePath}`);
-                await decryptFile(payload.filePath, payload.password);
-                parentPort.postMessage({ success: true }); // Pas de données à retourner
-                break;
+        case 'decrypt':
+            console.log(`[Worker] Received action: ${action} for file: ${payload.filePath}`);
+            await decryptFile(payload.filePath, payload.password);
+            parentPort.postMessage({ success: true }); // Pas de données à retourner
+            break;
+                
 
-            case 'hash':
-                console.log(`[Worker] Received action: hash`);
-                if (!payload.data) throw new Error('Data to hash is missing in payload.');
-                // Le worker gère à la fois la génération du "salt" et le hachage
-                const salt = await bcrypt.genSalt(10);
-                result = await bcrypt.hash(payload.data, salt);
-                parentPort.postMessage({ success: true, data: result }); // On retourne le hash
-                break;
+        case 'hash':
+            console.log(`[Worker] Received action: hash`);
+            if (!payload.data) throw new Error('Data to hash is missing in payload.');
+            // Le worker gère à la fois la génération du "salt" et le hachage
+            const salt = await bcrypt.genSalt(10);
+            result = await bcrypt.hash(payload.data, salt);
+            parentPort.postMessage({ success: true, data: result }); // On retourne le hash
+            break;
 
-            default:
-                throw new Error(`Unknown crypto action: ${action}`);
+        default:
+            throw new Error(`Unknown crypto action: ${action}`);
         }
     } catch (error) {
         // Envoie l'erreur au thread principal

package/src/workers/import-export-worker.js

@@ -5,27 +5,27 @@ parentPort.on('message', ({ action, payload }) => {
     try {
         let result;
         switch (action) {
-            case 'parse-json':
-                // Tâche: Parser une chaîne/buffer JSON en objet JS
-                result = JSON.parse(payload.fileContent.toString('utf-8'));
-                break;
+        case 'parse-json':
+            // Tâche: Parser une chaîne/buffer JSON en objet JS
+            result = JSON.parse(payload.fileContent.toString('utf-8'));
+            break;
 
-            case 'parse-csv':
-                // Tâche: Parser une chaîne/buffer CSV en tableau d'objets JS
-                result = parse(payload.fileContent, {
-                    columns: payload.options.columns,
-                    skip_empty_lines: true,
-                    trim: true,
-                });
-                break;
+        case 'parse-csv':
+            // Tâche: Parser une chaîne/buffer CSV en tableau d'objets JS
+            result = parse(payload.fileContent, {
+                columns: payload.options.columns,
+                skip_empty_lines: true,
+                trim: true
+            });
+            break;
 
-            case 'stringify-json':
-                // Tâche: Sérialiser un objet/tableau JS en chaîne JSON
-                result = JSON.stringify(payload.data);
-                break;
+        case 'stringify-json':
+            // Tâche: Sérialiser un objet/tableau JS en chaîne JSON
+            result = JSON.stringify(payload.data);
+            break;
 
-            default:
-                throw new Error(`Unknown action: ${action}`);
+        default:
+            throw new Error(`Unknown action: ${action}`);
         }
         // Renvoyer le résultat au thread principal
         parentPort.postMessage({ success: true, data: result });

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

@@ -6,25 +6,21 @@ import { Config } from '../src/config.js';
 import { ObjectId } from 'mongodb';
 import {expect, describe, it, beforeAll, afterAll, beforeEach} from 'vitest';
 import { vi } from 'vitest'
-import { Buffer } from 'node:buffer'; // Explicitly import Buffer
-import crypto from 'node:crypto';  //Explicitly import crypto
 
 import {
     createModel,
-    getModel, insertData
+    insertData
 } from 'data-primals-engine/modules/data';
 
 import {
     modelsCollection as getAppModelsCollection,
-    getCollectionForUser as getAppUserCollection,
+    getCollectionForUser as getAppUserCollection
 } from 'data-primals-engine/modules/mongodb';
-import { Engine } from "data-primals-engine/engine";
 import process from "node:process";
 
-import { dumpUserData, loadFromDump, getUserHash } from 'data-primals-engine/modules/data';
+import { dumpUserData, loadFromDump } from 'data-primals-engine/modules/data';
 import fs from "node:fs";
-import {getRandom} from "data-primals-engine/core";
-import {getUniquePort, initEngine, stopEngine} from "../src/setenv.js";
+import {initEngine} from "../src/setenv.js";
 
 vi.mock('data-primals-engine/engine', async(importOriginal) => {
     const mod = await importOriginal() // type is inferred
@@ -37,7 +33,6 @@ vi.mock('data-primals-engine/engine', async(importOriginal) => {
 const mockUser = {
     username: 'testuserBackup',
     _user: 'testuserBackup',
-    userPlan: 'premium',
     email: 'testBackup@example.com',
     configS3: {
         bucketName: null
@@ -50,9 +45,9 @@ const testModelDefinition = {
     description: 'Model for testing backup/restore',
     fields: [
         { name: 'testField', type: 'string', required: true },
-        { name: 'optionalField', type: 'number' },
+        { name: 'optionalField', type: 'number' }
     ],
-    maxRequestData: 10,
+    maxRequestData: 10
 };
 
 let testModelsColInstance;
@@ -101,7 +96,7 @@ beforeAll(async () =>{
 })
 beforeEach(async () => {
     testModelsColInstance = getAppModelsCollection;
-    testDatasColInstance = getAppUserCollection(mockUser);
+    testDatasColInstance = await getAppUserCollection(mockUser);
 });
 
 describe('Data Backup and Restore Integration', () => {

package/test/data.integration.test.js

@@ -14,8 +14,7 @@ import {
 import {
     modelsCollection as getAppModelsCollection,
     getCollection,
-    getCollectionForUser as getAppUserCollection,
-    datasCollection // Accès direct pour vérifications
+    getCollectionForUser as getAppUserCollection
 } from 'data-primals-engine/modules/mongodb';
 import { Engine } from "data-primals-engine/engine";
 import process from "node:process";
@@ -41,6 +40,9 @@ async function setupTestContext() {
         email: generateUniqueName('test') + '@example.com'
     };
 
+    // Initialize collection instances after the engine is ready
+    testModelsColInstance = getAppModelsCollection;
+    testDatasColInstance = await getAppUserCollection(currentTestUser);
 
     const relatedModelDefinition = {
         name: currentRelatedModelName,
@@ -50,7 +52,7 @@ async function setupTestContext() {
             {name: 'relatedName', type: 'string', required: true, unique: true},
             {name: 'relatedValue', type: 'number'}
         ],
-        maxRequestData: 10,
+        maxRequestData: 10
     };
 
     const comprehensiveTestModelDefinition = {
@@ -102,23 +104,25 @@ async function setupTestContext() {
             {name: 'objectField', type: 'object'},
             // Model & ModelField (validation of string format, not existence)
             {name: 'modelNameField', type: 'model'},
-            {name: 'modelFieldNameField', type: 'modelField'}, // Note: modelField type expects an object {model: 'modelName', field: 'fieldName'}
+            {name: 'modelFieldNameField', type: 'modelField'} // Note: modelField type expects an object {model: 'modelName', field: 'fieldName'}
         ],
-        maxRequestData: 50,
+        maxRequestData: 50
     };
 
-    // Insérer les modèles en base
-    await testModelsColInstance.insertMany([
-        comprehensiveTestModelDefinition,
-        relatedModelDefinition
-    ]);
+    if( await testModelsColInstance.find({ $or: [{name: comprehensiveTestModelDefinition.name}, {name: relatedModelDefinition.name}]})) {
+        // Insérer les modèles en base
+        await testModelsColInstance.insertMany([
+            comprehensiveTestModelDefinition,
+            relatedModelDefinition
+        ]);
+    }
     await testDatasColInstance.deleteMany({ _user: currentTestUser.username });
 
     // Retourner toutes les variables nécessaires pour un test
     return {
         currentTestUser,
         comprehensiveTestModelDefinition,
-        relatedModelDefinition,
+        relatedModelDefinition
     };
 }
 
@@ -128,9 +132,6 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
         await initEngine();
 
-        // Initialize collection instances after the engine is ready
-        testModelsColInstance = getAppModelsCollection;
-        testDatasColInstance = datasCollection;
     })
 
     describe('insertData avec comprehensiveTestModel', () => {
@@ -186,13 +187,14 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
                 codeJsField: 'console.log("hello");',
                 objectField: { a: 1, b: "test" },
                 modelNameField: 'someModelName',
-                modelFieldNameField: { model: 'someModelName', field: 'someFieldName' },
+                modelFieldNameField: { model: 'someModelName', field: 'someFieldName' }
             };
 
             const result = await insertData(comprehensiveTestModelDefinition.name, validData, {}, currentTestUser, false);
             expect(result.success, `L'insertion principale a échoué: ${result.error}`).toBe(true);
             expect(result.insertedIds).toHaveLength(1);
 
+            console.log(result);
             const insertedDoc = await testDatasColInstance.findOne({ _id: new ObjectId(result.insertedIds[0]) });
             expect(insertedDoc).not.toBeNull();
             expect(insertedDoc.stringRequired).toBe('Valid String');
@@ -365,7 +367,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
                 codeJsField: 'console.log("find");',
                 objectField: { find: "test" },
                 modelNameField: 'findModel',
-                modelFieldNameField: { model: 'findModel', field: 'findField' },
+                modelFieldNameField: { model: 'findModel', field: 'findField' }
             };
 
             // 3. Insérer le document principal
@@ -411,7 +413,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
                 stringUnique: 'UniqueForEdit',
                 enumField: 'alpha',
                 passwordField: 'initialPass',
-                relationSingle: relatedDocId,
+                relationSingle: relatedDocId
             };
             const insertResult = await insertData(comprehensiveTestModelDefinition.name, initialData, {}, currentTestUser, false);
             docToEditId = insertResult.insertedIds[0];
@@ -493,17 +495,17 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             await insertData(simpleModel.name, { name: 'Autre Item', value: 403 }, {}, currentTestUser, false);
 
             const filter = { $regexMatch: {
-                    input: '$name',
-                    regex: "^Item Filtrable"
-                } };
+                input: '$name',
+                regex: "^Item Filtrable"
+            } };
             const deleteResult = await deleteData(simpleModel.name, [], filter, currentTestUser, false);
 
             expect(deleteResult.success).toBe(true);
             expect(deleteResult.deletedCount).toBe(2);
 
-            const remainingCount = await testDatasColInstance.countDocuments({ _model: simpleModel.name, name: { $regex: "^Item Filtrable" } });
+            const remainingCount = await testDatasColInstance.countDocuments({ _user: currentTestUser.username, _model: simpleModel.name, name: { $regex: "^Item Filtrable" } });
             expect(remainingCount).toBe(0);
-            const totalRemaining = await testDatasColInstance.countDocuments({ _model: simpleModel.name });
+            const totalRemaining = await testDatasColInstance.countDocuments({ _user: currentTestUser.username, _model: simpleModel.name });
             expect(totalRemaining).toBe(1);
         });
     });
@@ -531,7 +533,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
                 passwordField: 'searchPass1',
                 relationSingle: relatedDocId_A1,
                 relationMultiple: [relatedDocId_A1, relatedDocId_A2],
-                number: 10,
+                number: 10
             };
             const insertResult1 = await insertData(comprehensiveTestModelDefinition.name, data1, {}, currentTestUser, false);
             docId1 = insertResult1.insertedIds[0].toString();
@@ -543,7 +545,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
                 passwordField: 'searchPass2',
                 relationSingle: relatedDocId_B1,
                 relationMultiple: [relatedDocId_B1],
-                number: 20,
+                number: 20
             };
             const insertResult2 = await insertData(comprehensiveTestModelDefinition.name, data2, {}, currentTestUser, false);
             docId2 = insertResult2.insertedIds[0].toString();
@@ -564,7 +566,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
                     },
                     autoExpand: true,
                     depth: 8
-                },
+                }
             };
             const { data, count } = await searchData(searchParams);
             expect(count).toBe(1);