data-primals-engine 1.0.10 → 1.1.0

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

package/test/globalSetup.js

@@ -4,7 +4,7 @@ import {getCollection} from "../src/modules/mongodb.js";
 
 export default async function () {
 
-// --- Configuration initiale ---
+    // --- Configuration initiale ---
     Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
 
     console.log('\n--- Global Setup: Initializing engine and database for all tests ---');
@@ -12,4 +12,4 @@ export default async function () {
 
     // Initialisez et exportez les collections
     console.log('--- Global Setup: Complete. Engine is running. ---');
-}
+}

package/test/import_export.integration.test.js

@@ -10,7 +10,7 @@ import {
 
 import {
     modelsCollection as getAppModelsCollection,
-    getCollectionForUser as getAppUserCollection,
+    getCollectionForUser as getAppUserCollection
 } from 'data-primals-engine/modules/mongodb';
 import {sleep} from "data-primals-engine/core";
 import fs from "node:fs";
@@ -33,8 +33,8 @@ const impexTestModel = {
         { name: 'name', type: 'string', required: true },
         { name: 'sku', type: 'string', unique: true },
         { name: 'price', type: 'number', required: true },
-        { name: 'inStock', type: 'boolean', default: true },
-    ],
+        { name: 'inStock', type: 'boolean', default: true }
+    ]
 };
 
 // --- Setup de l'environnement de test ---
@@ -62,7 +62,7 @@ describe('Intégration des fonctions d\'Import/Export', () => {
     // Préparation avant chaque test du bloc
     beforeEach(async () => {
         testModelsColInstance = getAppModelsCollection;
-        testDatasColInstance = getAppUserCollection(mockUser);
+        testDatasColInstance = await getAppUserCollection(mockUser);
 
         // Nettoyage complet pour un état propre
         await testDatasColInstance.deleteMany({ _user: "testuserImpex"});
@@ -74,7 +74,7 @@ describe('Intégration des fonctions d\'Import/Export', () => {
         await insertData(impexTestModel.name, [
             { name: 'Produit A', sku: 'SKU-A', price: 10.50, inStock: true },
             { name: 'Produit B', sku: 'SKU-B', price: 25.00, inStock: false },
-            { name: 'Produit C', sku: 'SKU-C', price: 99.99, inStock: true },
+            { name: 'Produit C', sku: 'SKU-C', price: 99.99, inStock: true }
         ], {}, mockUser, false);
     });
 
@@ -82,7 +82,7 @@ describe('Intégration des fonctions d\'Import/Export', () => {
         it('devrait exporter les données en format JSON', async () => {
             const res= await exportData({
                 models: [impexTestModel.name],
-                depth: 1,
+                depth: 1
             }, mockUser);
 
             expect(res.success).toBeTruthy();

package/test/model.integration.test.js

@@ -38,7 +38,7 @@ async function setupTestContext() {
             {name: 'relatedName', type: 'string', required: true, unique: true},
             {name: 'relatedValue', type: 'number'}
         ],
-        maxRequestData: 10,
+        maxRequestData: 10
     };
 
     const comprehensiveTestModelDefinition = {
@@ -90,9 +90,9 @@ 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
@@ -108,7 +108,7 @@ async function setupTestContext() {
     return {
         currentTestUser,
         comprehensiveTestModelDefinition,
-        relatedModelDefinition,
+        relatedModelDefinition
     };
 }
 
@@ -127,22 +127,21 @@ describe('CRUD on model definitions and integrity tests', () => {
         it('should create and drop index when field.index is toggled (premium user)', async () => {
             // --- SETUP ---
             const { currentTestUser, comprehensiveTestModelDefinition } = await setupTestContext();
-            const premiumUser = { ...currentTestUser, userPlan: 'premium' };
-            const dataCollection = getCollectionForUser(premiumUser);
+            const dataCollection = await getCollectionForUser(currentTestUser);
             const fieldToIndex = 'stringUnique'; // Utiliser un champ qui existe vraiment dans le modèle
 
+            // --- FIX: Ensure the collection exists before any operation ---
+            // By inserting and deleting a dummy document, we force MongoDB to create the
+            // collection and its default indexes. This prevents the "ns does not exist"
+            // error in asynchronous listeners (like workflow triggers).
+            const dummyDoc = await dataCollection.insertOne({ _model: 'dummy', _user: currentTestUser.username });
+            await dataCollection.deleteOne({ _id: dummyDoc.insertedId });
+
+
             // --- VERIFICATION INITIALE ---
             // S'assurer qu'aucun index n'existe au départ.
-            // On enveloppe l'appel dans un try/catch pour gérer le cas où la collection n'existe pas.
-            let initialIndexes = [];
-            try {
-                initialIndexes = await dataCollection.indexes();
-            } catch (e) {
-                // C'est normal si la collection n'existe pas encore. On considère qu'il n'y a pas d'index.
-                if (e.codeName !== 'NamespaceNotFound') {
-                    throw e; // Relancer les autres erreurs inattendues
-                }
-            }
+            // Cet appel ne plantera plus car la collection est maintenant créée.
+            const initialIndexes = await dataCollection.indexes();
             expect(initialIndexes.some(i => i.key[fieldToIndex] === 1)).toBe(false);
 
             // --- ACTION 1 : AJOUTER UN INDEX ---
@@ -150,9 +149,9 @@ describe('CRUD on model definitions and integrity tests', () => {
                 ...comprehensiveTestModelDefinition,
                 fields: comprehensiveTestModelDefinition.fields.map(f =>
                     f.name === fieldToIndex ? { ...f, index: true } : f
-                ),
+                )
             };
-            await editModel(premiumUser, testModelId, modelWithIndex);
+            await editModel(currentTestUser, testModelId, modelWithIndex);
 
             // --- VERIFICATION 1 ---
             // Maintenant, la collection et l'index doivent exister.
@@ -163,7 +162,7 @@ describe('CRUD on model definitions and integrity tests', () => {
             // Le filtre partiel est crucial pour que l'index ne s'applique qu'aux bonnes données
             expect(newIndex.partialFilterExpression).toEqual({
                 _model: comprehensiveTestModelDefinition.name,
-                _user: premiumUser.username,
+                _user: currentTestUser.username
             });
 
             // --- ACTION 2 : SUPPRIMER L'INDEX ---
@@ -171,14 +170,14 @@ describe('CRUD on model definitions and integrity tests', () => {
                 ...comprehensiveTestModelDefinition,
                 fields: comprehensiveTestModelDefinition.fields.map(f =>
                     f.name === fieldToIndex ? { ...f, index: false } : f
-                ),
+                )
             };
-            await editModel(premiumUser, testModelId, modelWithoutIndex);
+            await editModel(currentTestUser, testModelId, modelWithoutIndex);
 
             // --- VERIFICATION 2 ---
             const indexesAfterDeletion = await dataCollection.indexes();
             expect(indexesAfterDeletion.some(i => i.key[fieldToIndex] === 1)).toBe(false);
-        }, 20000); // Augmenter le timeout si nécessaire pour les opérations d'index
+        }, 20000);
 
         it('should not save extra, non-defined fields in the model definition', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();