data-primals-engine 1.2.2 → 1.2.3

package/src/packs.js

@@ -39,6 +39,14 @@ export const getAllPacks = async () => {
         return perms;
     }
 
+    const envSmtp = [
+        { "name": "SMTP_HOST", "value": "smtp.example.com", "description": "SMTP server host for sending emails." },
+        { "name": "SMTP_PORT", "value": "587", "description": "SMTP server port." },
+        { "name": "SMTP_USER", "value": "user@example.com", "description": "Username for SMTP authentication." },
+        { "name": "SMTP_PASS", "value": "your_smtp_password", "description": "Password for SMTP authentication." },
+        { "name": "SMTP_FROM", "value": "\"My Store\" <noreply@example.com>", "description": "The 'From' address for outgoing emails." }
+    ];
+
     const categories = [ 'News', 'Blog', 'Products', 'Services', 'Store', 'Events', 'Forums', 'Contact', 'Support'];
     const tags = [ 'info', 'incident', 'maintenance', 'feature', 'hint', 'bugfix', 'question'];
 
@@ -48,6 +56,242 @@ export const getAllPacks = async () => {
         {name: 'visitor', perms: ['API_SEARCH_DATA_webpage','API_SEARCH_DATA_content', 'API_SEARCH_DATA_lang', 'API_SEARCH_DATA_currency', 'API_SEARCH_DATA_taxonomy']}];
 
     return [
+        {
+            "name": "Marketing & Campaigning",
+            "description": "Launch powerful, personalized, and scalable email campaigns. This pack uses dynamic audiences and a robust workflow to send emails in chunks, ensuring high performance. Depends on the 'Customer Relationship Management (CRM)' pack.",
+            "tags": ["marketing", "email", "campaign", "workflow"],
+            "models": ["env", "contact", "workflow", "workflowStep", "workflowAction", "workflowRun", "workflowTrigger",
+                {
+                    "name": "campaign",
+                    "description": "Defines an email marketing campaign.",
+                    "fields": [
+                        { "name": "name", "type": "string", "required": true, "asMain": true },
+                        { "name": "subject", "type": "string", "required": true },
+                        { "name": "content", "type": "richtext", "required": true },
+                        { "name": "status", "type": "enum", "items": ["draft", "scheduled", "in_progress", "finished", "cancelled"], "default": "draft" },
+                        { "name": "audience", "type": "relation", "relation": "audience" },
+                        { "name": "processedRecipients", "type": "array", "itemsType": "string", "hint": "List of processed contact IDs." }
+                    ]
+                },
+                {
+                    "name": "audience",
+                    "description": "Defines a dynamic segment of contacts based on a filter.",
+                    "fields": [
+                        { "name": "name", "type": "string", "required": true, "asMain": true },
+                        { "name": "description", "type": "string" },
+                        { "name": "filter", "type": "code", "language": "json", "required": true, "conditionBuilder": true, "hint": "A MongoDB filter to select contacts. E.g., { \"tags\": \"newsletter\" }" }
+                    ]
+                }
+            ],
+            "data":{
+                "all": {
+                    "audience": [
+                        {
+                            "name": "Example Audience for Campaigning",
+                            "description": "An example audience targeting specific contacts from the CRM pack.",
+                            "filter": { "$or": [{ "$eq": ["$email", "alice.martin@innovatech.com"] }, { "$eq": ["$email", "bob.durand@globalexports.com"] }] }
+                        }
+                    ],
+                    "campaign": [
+                        {
+                            "name": "Q3 Product Launch",
+                            "subject": "🚀 Discover Our New Products!",
+                            "content": "<h1>Hello {recipient.firstName},</h1><p>We are excited to introduce our latest product line. We think you'll love it!</p><p>Best regards,<br>The Team</p>",
+                            "status": "draft",
+                            "audience": { "$link": { "name": "Example Audience for Campaigning", "_model": "audience" } }
+                        }
+                    ],
+                    "workflow": [{
+                        "name": "Campaign Emailing Workflow",
+                        "description": "A scalable workflow that sends campaign emails in chunks by dynamically querying contacts from an audience.",
+                        "startStep": { "$link": { "name": "Start Campaign Processing", "_model": "workflowStep" } }
+                    }],
+                    "workflowAction": [
+                        {
+                            "name": "Set Campaign to 'in_progress'",
+                            "type": "UpdateData",
+                            "targetModel": "campaign",
+                            "targetSelector": { "_id": "{triggerData._id}" },
+                            "fieldsToUpdate": { "status": "in_progress" }
+                        },
+                        {
+                            "name": "Get Next Recipient Chunk",
+                            "type": "ExecuteScript",
+                            "script": `
+const chunkSize = 10; // Process 10 recipients per run
+const campaign = context.triggerData;
+const audience = await db.findOne("audience",{"_id": campaign.audience});
+
+if (!audience || !audience.filter) {
+logger.error('Campaign audience or audience filter is not defined.');
+return { chunk: [], message: 'Campaign audience or audience filter is not defined.'}; // Returning an empty chunk will stop the workflow.
+}
+
+const processedIds = campaign.processedRecipients || [];
+
+const query = {
+    '$and': [
+        audience.filter,
+        { '$not':{ '$in': ["$_id", processedIds] } }
+    ]
+};
+
+logger.info('Finding next chunk with filter:', JSON.stringify(query));
+
+const searchResult = await db.find('contact', query, { limit: chunkSize });
+const chunk = searchResult.data || [];
+
+logger.info(\`Found \${chunk.length} recipients for the next chunk.\`);
+
+return { chunk }; // This chunk is passed to the next action via context.result
+`
+                        },
+                        {
+                            "name": "Send Email to Chunk",
+                            "type": "SendEmail",
+                            "emailRecipients": ["{context.result.chunk}"],
+                            "emailSubject": "{triggerData.subject}",
+                            "emailContent": "{triggerData.content}"
+                        },
+                        {
+                            "name": "Update Processed Recipients",
+                            "type": "ExecuteScript",
+                            "script": `
+const campaignId = context.triggerData._id;
+const emailResult = context.emailResult; 
+
+if (!emailResult || !Array.isArray(emailResult.sent) || emailResult.sent.length === 0) {
+    logger.info('No recipients were successfully sent an email in this chunk.');
+    // Return the original chunk from the first script to allow the condition to check it
+    return { processedChunk: context.result.chunk };
+}
+
+const processedIds = emailResult.sent.map(recipient => recipient._id.toString());
+
+logger.info(\`Updating campaign \${campaignId} with \${processedIds.length} new processed IDs.\`);
+
+await db.update(
+    'campaign',
+    { _id: campaignId },
+    { 'processedRecipients': [...campaign.processedRecipients, ...processedIds] }
+);
+
+// Return the original chunk for the condition check step
+return { processedChunk: context.result.chunk };
+`
+                        },
+                        {
+                            "name": "Set Campaign to 'finished'",
+                            "type": "UpdateData",
+                            "targetModel": "campaign",
+                            "targetSelector": { "_id": "{triggerData._id}" },
+                            "fieldsToUpdate": { "status": "finished" }
+                        }
+                    ],
+                    "workflowStep": [
+                        {
+                            "name": "Start Campaign Processing",
+                            "workflow": { "$link": { "name": "Campaign Emailing Workflow", "_model": "workflow" } },
+                            "actions": { "$link": { "name": "Set Campaign to 'in_progress'", "_model": "workflowAction" } },
+                            "onSuccessStep": { "$link": { "name": "Process Recipient Chunk", "_model": "workflowStep" } }
+                        },
+                        {
+                            "name": "Process Recipient Chunk",
+                            "workflow": { "$link": { "name": "Campaign Emailing Workflow", "_model": "workflow" } },
+                            "actions":
+                                { "$link": { "$or": [
+                                    {"$eq": ["$name", "Get Next Recipient Chunk"]},
+                                    {"$eq": ["$name", "Send Email to Chunk"]},
+                                    {"$eq": ["$name", "Update Processed Recipients"]}
+                                ],"_model": "workflowAction"}},
+                            "onSuccessStep": { "$link": { "name": "Check if Campaign is Complete", "_model": "workflowStep" } }
+                        },
+                        {
+                            "name": "Check if Campaign is Complete",
+                            "workflow": { "$link": { "name": "Campaign Emailing Workflow", "_model": "workflow" } },
+                            "conditions": { "$gt": [{ "$size": {$ifNull:["{context.result.processedChunk}", []]} }, 0] },
+                            "onSuccessStep": { "$link": { "name": "Process Recipient Chunk", "_model": "workflowStep" } },
+                            "onFailureStep": { "$link": { "name": "Finish Campaign", "_model": "workflowStep" } }
+                        },
+                        {
+                            "name": "Finish Campaign",
+                            "workflow": { "$link": { "name": "Campaign Emailing Workflow", "_model": "workflow" } },
+                            "actions": { "$link": { "name": "Set Campaign to 'finished'", "_model": "workflowAction" } },
+                            "isTerminal": true
+                        }
+                    ],
+                    "workflowTrigger": [{
+                        "name": "On Campaign Scheduled",
+                        "workflow": { "$link": { "name": "Campaign Emailing Workflow", "_model": "workflow" } },
+                        "type": "manual",
+                        "onEvent": "DataEdited",
+                        "targetModel": "campaign",
+                        "dataFilter": { "$eq": ["$status", "scheduled"] },
+                        "isActive": true
+                    }],
+                    "env": envSmtp
+                }
+            }
+        },
+        /*
+        {
+            "name": "Social Media Publisher",
+            "description": "Automate your social media presence. This pack provides a workflow to automatically post new blog articles to Twitter and LinkedIn. Requires the 'Website Starter Pack'.",
+            "tags": ["social media", "marketing", "automation", "workflow"],
+            "dependencies": ["Website Starter Pack"],
+            "models": ["workflow", "workflowStep", "workflowAction", "workflowTrigger", "env"],
+            "data": {
+                "all": {
+                    "workflow": [{
+                        "name": "Publish New Blog Post to Socials",
+                        "description": "Automatically posts a link to a new blog post on Twitter and LinkedIn.",
+                        "startStep": {"$link": {"name": "Post on Social Networks", "_model": "workflowStep"}}
+                    }],
+                    "workflowAction": [
+                        {
+                            "name": "Post to Twitter",
+                            "type": "PostToSocialMedia",
+                            "provider": "Twitter",
+                            "content": "📰 New blog post published: {triggerData.title}! Check it out here: https://your-website.com/blog/{triggerData.slug}"
+                        },
+                        {
+                            "name": "Post to LinkedIn",
+                            "type": "PostToSocialMedia",
+                            "provider": "LinkedIn",
+                            "content": "We've just published a new article: '{triggerData.title}'.\n\n{triggerData.summary}\n\nRead the full post on our blog: https://your-website.com/blog/{triggerData.slug}\n#YourIndustry #BlogPost"
+                        }
+                    ],
+                    "workflowStep": [{
+                        "name": "Post on Social Networks",
+                        "workflow": {"$link": {"name": "Publish New Blog Post to Socials", "_model": "workflow"}},
+                        "actions": {
+                            "$link": {
+                                "$or": [
+                                    {"$eq": ["$name", "Post to Twitter"]},
+                                    {"$eq": ["$name", "Post to LinkedIn"]}
+                                ],
+                                "_model": "workflowAction"
+                            }
+                        },
+                        "isTerminal": true
+                    }],
+                    "workflowTrigger": [{
+                        "name": "On New Blog Post Added",
+                        "workflow": {"$link": {"name": "Publish New Blog Post to Socials", "_model": "workflow"}},
+                        "type": "manual",
+                        "onEvent": "DataAdded",
+                        "targetModel": "content",
+                        "dataFilter": {"category": {"$find": {"name": "Blog"}}},
+                        "isActive": true
+                    }],
+                    "env": [
+                        {"name": "TWITTER_API_KEY", "value": "your_key_here"},
+                        {"name": "TWITTER_API_SECRET", "value": "your_secret_here"},
+                        {"name": "LINKEDIN_ACCESS_TOKEN", "value": "your_token_here"}
+                    ]
+                }
+            }
+        },*/
         {
             "name": "E-commerce Starter Kit",
             "description": "Launch your online store in just a few clicks. This pack includes templates for products, orders, and customers, as well as sample data, KPIs, alerts and an order fulfillment workflow (with sending email).",
@@ -55,13 +299,7 @@ export const getAllPacks = async () => {
             "models": ["env", "taxonomy", "product", "productVariant", "brand", "currency", "order", "shipment", "review", "cart", "cartItem", "discount", "workflow", "workflowStep", "workflowAction","workflowRun", "workflowTrigger", "translation", "lang", "kpi", "dashboard", "alert", "return"],
             "data": {
                 "all": {
-                    "env": [
-                        { "name": "SMTP_HOST", "value": "smtp.example.com", "description": "SMTP server host for sending emails." },
-                        { "name": "SMTP_PORT", "value": "587", "description": "SMTP server port." },
-                        { "name": "SMTP_USER", "value": "user@example.com", "description": "Username for SMTP authentication." },
-                        { "name": "SMTP_PASS", "value": "your_smtp_password", "description": "Password for SMTP authentication." },
-                        { "name": "SMTP_FROM", "value": "\"My Store\" <noreply@example.com>", "description": "The 'From' address for outgoing emails." }
-                    ],
+                    "env":envSmtp,
                     "taxonomy": [
                         { "name": "E-commerce", "type": "category" },
                         { "name": "Clothes", "type": "category", "parent": { "$find": { "name": "E-commerce" } } },

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

@@ -14,13 +14,14 @@ import {
 
 import {
     modelsCollection as getAppModelsCollection,
-    getCollectionForUser as getAppUserCollection
+    getCollectionForUser as getAppUserCollection, getCollectionForUser
 } from 'data-primals-engine/modules/mongodb';
 import process from "node:process";
 
 import { dumpUserData, loadFromDump } from 'data-primals-engine/modules/data';
 import fs from "node:fs";
 import {initEngine} from "../src/setenv.js";
+import {getUserCollectionName} from "../src/modules/mongodb.js";
 
 vi.mock('data-primals-engine/engine', async(importOriginal) => {
     const mod = await importOriginal() // type is inferred
@@ -88,6 +89,8 @@ afterAll(async () => {
         });
         fs.rmdirSync(backupDir); // Remove the directory itself
     }
+    const coll = await getCollectionForUser(mockUser);
+    await coll.drop()
 });
 
 beforeAll(async () =>{

package/test/data.integration.test.js

@@ -1,22 +1,25 @@
 // __tests__/data.integration.test.js
 import { ObjectId } from 'mongodb';
-import {expect, describe, it, beforeEach, beforeAll, afterAll} from 'vitest';
+import {vi, expect, describe, it, beforeEach, beforeAll, afterAll} from 'vitest';
 import { Config } from '../src/config.js';
-
 import {
     insertData,
     editData,
     deleteData,
-    searchData, installPack, deleteModels, createModel
+    searchData, installPack, deleteModels, createModel, patchData
 } from 'data-primals-engine/modules/data';
 
 import {
     modelsCollection as getAppModelsCollection,
     getCollection,
-    getCollectionForUser as getAppUserCollection
+    getCollectionForUser as getAppUserCollection, getCollectionForUser
 } from 'data-primals-engine/modules/mongodb';
 import {getRandom} from "../src/core.js";
 import {generateUniqueName, initEngine} from "../src/setenv.js";
+import {processWorkflowRun} from "data-primals-engine/modules/workflow";
+import {sendEmail} from "../src/email.js";
+import {MongoDatabase} from "../src/engine.js";
+import {getUserCollectionName} from "../src/modules/mongodb.js";
 
 let testModelsColInstance;
 let testDatasColInstance;
@@ -828,6 +831,8 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             await deleteModels({ name: orderModel.name, _user: user.username });
             await deleteData(productModel.name, {}, user);
             await deleteData(orderModel.name, {}, user);
+            const coll = await getCollectionForUser(user);
+            await coll.drop();
         });
 
         it('should ALLOW inserting data with a valid relation', async () => {
@@ -871,4 +876,5 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             await deleteData(orderModel.name, initialOrder.insertedIds, user);
         });
     });
+
 });

package/test/file.test.js

@@ -7,9 +7,10 @@ import { fileURLToPath } from 'node:url';
 import { ObjectId } from 'mongodb';
 import { initEngine, generateUniqueName } from "../src/setenv.js";
 import { addFile, removeFile, getFile, onInit } from "../src/modules/file.js";
-import { getCollection } from "../src/modules/mongodb.js";
+import {getCollection, getUserCollectionName} from "../src/modules/mongodb.js";
 import { Logger } from "../src/gameObject.js";
 import {maxPrivateFileSize} from "../src/constants.js";
+import {getCollectionForUser} from "data-primals-engine/modules/mongodb";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -46,19 +47,17 @@ beforeAll(async () => {
 
     filesCollection = await getCollection("files");
 });
-describe('File Module Integration Tests', () => {
-    let testUser;
+let testUser = {
+    username: generateUniqueName('testuser'),
+    _user: generateUniqueName('testuser'),
+    userPlan: 'premium',
+    permissions: ['API_UPLOAD_FILE']
+};
 
+describe('File Module Integration Tests', () => {
 
     beforeEach(async () => {
         // Créer un utilisateur de test
-        testUser = {
-            username: generateUniqueName('testuser'),
-            _user: generateUniqueName('testuser'),
-            userPlan: 'premium',
-            permissions: ['API_UPLOAD_FILE']
-        };
-
         // Nettoyer les collections avant chaque test
         await filesCollection.deleteMany({});
 
@@ -109,8 +108,7 @@ describe('File Module Integration Tests', () => {
             await expect(addFile(mockFile, testUser)).rejects.toThrow(/La taille du fichier dépasse la limite autorisée/);
         });
 
-        it('should throw error when storage limit exceeded', async ({skip}) => {
-            skip();
+        it.skip('should throw error when storage limit exceeded', async ({skip}) => {
             // Mock la fonction de calcul d'usage pour simuler un dépassement
             vi.spyOn(engine.userProvider, 'getUserStorageLimit').mockResolvedValue(85 * 1024 * 1024); // 5MB
 
@@ -119,8 +117,7 @@ describe('File Module Integration Tests', () => {
             await expect(addFile(mockFile, testUser)).rejects.toThrow("api.data.storageLimitExceeded");
         });
 
-        it('should throw error when server capacity is insufficient', async ({skip}) => {
-            skip();
+        it.skip('should throw error when server capacity is insufficient', async ({skip}) => {
             // Mock la vérification de capacité serveur
             vi.spyOn(engine.userProvider, 'checkServerCapacity').mockResolvedValue({ isSufficient: false });
 

package/test/import_export.integration.test.js

@@ -2,20 +2,20 @@ import {expect, describe, it, beforeEach, beforeAll, afterAll, vi} from 'vitest'
 
 // --- Importations des modules de votre application ---
 import {
-    createModel,
     insertData,
     exportData,
     importData
-} from 'data-primals-engine/modules/data';
+} from '../src/index.js';
 
 import {
     modelsCollection as getAppModelsCollection,
-    getCollectionForUser as getAppUserCollection
+    getCollectionForUser as getAppUserCollection, getCollectionForUser
 } from 'data-primals-engine/modules/mongodb';
 import {sleep} from "data-primals-engine/core";
 import fs from "node:fs";
 import {getUniquePort, initEngine} from "../src/setenv.js";
 import {Config} from "../src/index.js";
+import {ObjectId} from "mongodb";
 
 // --- Données Mock ---
 const mockUser = {
@@ -56,6 +56,10 @@ beforeAll(async () =>{
     Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
     await initEngine();
 })
+afterAll(async () => {
+    const coll = await getCollectionForUser(mockUser);
+    await coll.drop();
+})
 // --- Début des tests ---
 describe('Intégration des fonctions d\'Import/Export', () => {
 
@@ -114,13 +118,13 @@ describe('Intégration des fonctions d\'Import/Export', () => {
             fs.writeFileSync('test.json', jsonString);
             blob.path = 'test.json';
             blob.originalFilename = 'test.json';
-            const result = await importData({model: impexTestModel.name}, {file: blobToFile(blob,"test.json")}, mockUser);
+            const result = await importData({model: impexTestModel.name}, {file: blobToFile(blob, "test.json")}, mockUser);
 
             // Vérifications du résultat de l'opération
             expect(result.success).toBe(true);
-            expect(result.jobId).not.toBeNull();
+            expect(result.job.jobId).not.toBeNull();
 
-            await sleep(2000);
+            await sleep(8000)
 
             // Vérification directe en base de données
             const importedDocs = await testDatasColInstance.find({
@@ -136,7 +140,7 @@ describe('Intégration des fonctions d\'Import/Export', () => {
             expect(docD.inStock).toBe(true); // Vérification de la valeur par défaut
             expect(docE.price).toBe(2.00);
 
-        }, 5000);
+        }, 20000);
 
         it('devrait importer des données depuis une chaîne CSV et convertir les types', async () => {
             const csvStringToImport = `name,sku,price,inStock\nProduit F,SKU-F,3.55,true\nProduit G,SKU-G,4.99,false`;
@@ -148,14 +152,13 @@ describe('Intégration des fonctions d\'Import/Export', () => {
             blob.originalFilename = 'test.csv';
 
             // Exécution de la fonction d'import
-            const result = await importData({model:impexTestModel.name}, {file: blobToFile(blob,"test.csv")}, mockUser);
+            const result = await importData({model:impexTestModel.name}, {file: blobToFile(blob, "test.csv")}, mockUser);
 
-            console.log(result)
             // Vérifications du résultat
             expect(result.success).toBe(true);
+            expect(result.job.jobId).not.toBeNull();
 
-            await sleep(2000);
-
+            await sleep(8000);
             // Vérification en base de données
             const importedDocs = await testDatasColInstance.find({
                 _model: impexTestModel.name,
@@ -185,16 +188,17 @@ Valide K,SKU-A,40,true`;
             blob.path = 'test.csv';
             blob.originalFilename = 'test.csv';
 
-            const result = await importData(impexTestModel.name, {file: blobToFile(blob,"test.csv")}, 'csv', mockUser);
+            const result = await importData({ model: impexTestModel.name }, {file: blobToFile(blob,"test.csv")}, mockUser);
 
-            console.log(result);
-            // Vérifications du résultat
-            expect(result.success).toBe(true); // L'opération globale a des erreurs
-            expect(result.job.status).toBe('failed'); // L'opération globale a des erreurs
+            // L'initiation du job doit réussir
+            expect(result.success).toBe(true);
+            expect(result.job.jobId).not.toBeNull();
+
+            await sleep(8000);
 
             // Vérifier que seule les données valides sont en BDD
-            const count = await testDatasColInstance.countDocuments({ _model: impexTestModel.name });
-            expect(count).toBe(3);
-        });
+            const count = await testDatasColInstance.countDocuments({ _model: impexTestModel.name, sku: 'SKU-H' });
+            expect(count).toBe(1); // Seule la ligne valide 'SKU-H' doit être insérée.
+        }, 20000);
     });
 });

package/test/model.integration.test.js

@@ -5,30 +5,31 @@ import { Config } from '../src/config.js';
 
 import {
     modelsCollection as getAppModelsCollection,
-    datasCollection // Accès direct pour vérifications
+    datasCollection, getCollection // Accès direct pour vérifications
 } from 'data-primals-engine/modules/mongodb';
 import {generateUniqueName, getUniquePort, initEngine} from "../src/setenv.js";
 import {editModel} from "../src/modules/data.js";
-import {getCollectionForUser} from "../src/modules/mongodb.js";
+import {getCollectionForUser, getUserCollectionName} from "../src/modules/mongodb.js";
 
 let testModelsColInstance;
-let testDatasColInstance;
-
 let testModelId;
-
+let lastUser;
 // Cette fonction va remplacer la logique de votre beforeEach pour la création de contexte
 async function setupTestContext() {
 
     const currentTestModelName = generateUniqueName('relatedModel');
     const currentRelatedModelName = generateUniqueName('comprehensiveModel');
 
+
     // Créer un utilisateur unique pour ce test
     const currentTestUser = {
-        username: generateUniqueName('testuserDataIntegration'),
-        userPlan: 'free',
+        username: generateUniqueName('testuserModelIntegration'),
+        userPlan: 'premium',
         email: generateUniqueName('test') + '@example.com'
     };
 
+    testModelsColInstance = getCollection("models");
+    const testDatasColInstance = await getCollectionForUser(currentTestUser);
 
     const relatedModelDefinition = {
         name: currentRelatedModelName,
@@ -105,43 +106,42 @@ async function setupTestContext() {
     await testDatasColInstance.deleteMany({ _user: currentTestUser.username });
     await testDatasColInstance.deleteMany({ _model: { $in: [comprehensiveTestModelDefinition.name, 'renamedTestModel'] } });
     // Retourner toutes les variables nécessaires pour un test
+
     return {
         currentTestUser,
+        coll:testDatasColInstance,
         comprehensiveTestModelDefinition,
         relatedModelDefinition
     };
 }
 
+
 describe('CRUD on model definitions and integrity tests', () => {
 
     beforeAll(async () =>{
         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('editModel unit tests', () => {
 
-        it('should create and drop index when field.index is toggled (premium user)', async () => {
+        it.skip('should create and drop index when field.index is toggled (premium user)', async () => {
             // --- SETUP ---
-            const { currentTestUser, comprehensiveTestModelDefinition } = await setupTestContext();
-            const dataCollection = await getCollectionForUser(currentTestUser);
+            const { coll, currentTestUser, comprehensiveTestModelDefinition } = await setupTestContext();
             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 });
+            const dummyDoc = await coll.insertOne({ _model: 'dummy', _user: currentTestUser.username });
+            await coll.deleteOne({ _id: dummyDoc.insertedId });
 
 
             // --- VERIFICATION INITIALE ---
             // S'assurer qu'aucun index n'existe au départ.
             // Cet appel ne plantera plus car la collection est maintenant créée.
-            const initialIndexes = await dataCollection.indexes();
+            const initialIndexes = await coll.indexes();
             expect(initialIndexes.some(i => i.key[fieldToIndex] === 1)).toBe(false);
 
             // --- ACTION 1 : AJOUTER UN INDEX ---
@@ -155,7 +155,7 @@ describe('CRUD on model definitions and integrity tests', () => {
 
             // --- VERIFICATION 1 ---
             // Maintenant, la collection et l'index doivent exister.
-            const indexesAfterCreation = await dataCollection.indexes();
+            const indexesAfterCreation = await coll.indexes();
             const newIndex = indexesAfterCreation.find(i => i.key[fieldToIndex] === 1);
 
             expect(newIndex).toBeDefined();
@@ -175,8 +175,9 @@ describe('CRUD on model definitions and integrity tests', () => {
             await editModel(currentTestUser, testModelId, modelWithoutIndex);
 
             // --- VERIFICATION 2 ---
-            const indexesAfterDeletion = await dataCollection.indexes();
+            const indexesAfterDeletion = await coll.indexes();
             expect(indexesAfterDeletion.some(i => i.key[fieldToIndex] === 1)).toBe(false);
+
         }, 20000);
 
         it('should not save extra, non-defined fields in the model definition', async () => {