data-primals-engine 1.0.8 → 1.0.9

package/test/globalSetup.js

@@ -0,0 +1,15 @@
+import { initEngine } from '../src/setenv.js';
+import { Config } from '../src/config.js';
+import {getCollection} from "../src/modules/mongodb.js";
+
+export default async function () {
+
+// --- Configuration initiale ---
+    Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
+
+    console.log('\n--- Global Setup: Initializing engine and database for all tests ---');
+    // The initEngine function is already a singleton, so this is safe.
+
+    // Initialisez et exportez les collections
+    console.log('--- Global Setup: Complete. Engine is running. ---');
+}

package/test/globalTeardown.js

@@ -0,0 +1,8 @@
+
+import { stopEngine } from '../src/setenv.js';
+
+export default async function () {
+    console.log('\n--- Global Teardown: Stopping engine and database ---');
+    await stopEngine();
+    console.log('--- Global Teardown: Cleanup complete. ---');
+}

package/test/import_export.integration.test.js

@@ -0,0 +1,200 @@
+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';
+
+import {
+    modelsCollection as getAppModelsCollection,
+    getCollectionForUser as getAppUserCollection,
+} 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";
+
+// --- Données Mock ---
+const mockUser = {
+    username: 'testuserImpex',
+    _user: 'testuserImpex',
+    userPlan: 'premium',
+    email: 'testImpex@example.com'
+};
+
+const impexTestModel = {
+    name: 'impex_products',
+    description: 'test',
+    _user: mockUser.username,
+    fields: [
+        { name: 'name', type: 'string', required: true },
+        { name: 'sku', type: 'string', unique: true },
+        { name: 'price', type: 'number', required: true },
+        { name: 'inStock', type: 'boolean', default: true },
+    ],
+};
+
+// --- Setup de l'environnement de test ---
+let mongod;
+let testDbUri;
+const testDbName = 'testIntegrationDbHO_Impex';
+let testModelsColInstance;
+let testDatasColInstance;
+let engineInstance;
+const port = getUniquePort(); // Port unique pour cette suite de tests
+function blobToFile(theBlob, fileName){
+    //A Blob() is almost a File() - it's just missing the two properties below which we will add
+    theBlob.lastModifiedDate = new Date();
+    theBlob.name = fileName;
+    return theBlob;
+}
+
+beforeAll(async () =>{
+    Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
+    await initEngine();
+})
+// --- Début des tests ---
+describe('Intégration des fonctions d\'Import/Export', () => {
+
+    // Préparation avant chaque test du bloc
+    beforeEach(async () => {
+        testModelsColInstance = getAppModelsCollection;
+        testDatasColInstance = getAppUserCollection(mockUser);
+
+        // Nettoyage complet pour un état propre
+        await testDatasColInstance.deleteMany({ _user: "testuserImpex"});
+
+        if( await testModelsColInstance.find({ name: impexTestModel.name, _user: mockUser.username }).count() === 0) {
+            await testModelsColInstance.insertOne(impexTestModel);
+        }
+        // Insérer des données de base pour les tests d'exportation
+        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 },
+        ], {}, mockUser, false);
+    });
+
+    describe('Export de données', () => {
+        it('devrait exporter les données en format JSON', async () => {
+            const res= await exportData({
+                models: [impexTestModel.name],
+                depth: 1,
+            }, mockUser);
+
+            expect(res.success).toBeTruthy();
+
+            const data = res.data[impexTestModel.name];
+            expect(data).toBeInstanceOf(Array);
+            expect(data).toHaveLength(3);
+            expect(data[0]).toMatchObject({ name: 'Produit A', sku: 'SKU-A', price: 10.50 });
+            // Les champs système (_id, _model, _user, _hash) ne devraient pas être exportés par défaut
+            expect(data[0]).not.toHaveProperty('_model');
+        });
+
+        it('devrait lever une exception si le modèle n\'existe pas', async () => {
+            // La fonction devrait rejeter la promesse ou lancer une erreur
+            await expect((await exportData('model_inexistant', 'json', mockUser)).success).toBeFalsy();
+        });
+    });
+
+    describe('Import de données', () => {
+        it('devrait importer des données depuis une chaîne JSON', async () => {
+            const jsonDataToImport = [
+                { name: 'Produit D', sku: 'SKU-D', price: 1.00, inStock: true },
+                { name: 'Produit E', sku: 'SKU-E', price: 2.00 } // inStock utilisera la valeur par défaut
+            ];
+            const jsonString = JSON.stringify(jsonDataToImport);
+
+            // Exécution de la fonction d'import (hypothétique)x
+            var blob = new Blob([jsonString], {type: "application/json"});
+            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);
+
+            // Vérifications du résultat de l'opération
+            expect(result.success).toBe(true);
+            expect(result.jobId).not.toBeNull();
+
+            await sleep(2000);
+
+            // Vérification directe en base de données
+            const importedDocs = await testDatasColInstance.find({
+                _model: impexTestModel.name,
+                sku: { $in: ['SKU-D', 'SKU-E'] }
+            }).toArray();
+
+            expect(importedDocs).toHaveLength(2);
+            const docD = importedDocs.find(d => d.sku === 'SKU-D');
+            const docE = importedDocs.find(d => d.sku === 'SKU-E');
+
+            expect(docD.name).toBe('Produit D');
+            expect(docD.inStock).toBe(true); // Vérification de la valeur par défaut
+            expect(docE.price).toBe(2.00);
+
+        }, 5000);
+
+        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`;
+
+            // Exécution de la fonction d'import (hypothétique)x
+            var blob = new Blob([csvStringToImport], {type: "text/csv"});
+            fs.writeFileSync('test.csv', csvStringToImport);
+            blob.path = 'test.csv';
+            blob.originalFilename = 'test.csv';
+
+            // Exécution de la fonction d'import
+            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);
+
+            await sleep(2000);
+
+            // Vérification en base de données
+            const importedDocs = await testDatasColInstance.find({
+                _model: impexTestModel.name,
+                sku: { $in: ['SKU-F', 'SKU-G'] }
+            }).toArray();
+
+            expect(importedDocs).toHaveLength(2);
+            const docF = importedDocs.find(d => d.sku === 'SKU-F');
+            const docG = importedDocs.find(d => d.sku === 'SKU-G');
+
+            // Vérification de la conversion des types
+            expect(docF.price).toBe(3.55);
+            expect(docF.inStock).toBe(true);
+            expect(docG.inStock).toBe(false);
+        }, 20000);
+
+        it('devrait rejeter les lignes invalides et rapporter les erreurs', async () => {
+            const csvStringToImport = `name,sku,price,inStock
+Valide H,SKU-H,10,true
+,SKU-I,20,true
+Valide J,SKU-J,,false
+Valide K,SKU-A,40,true`;
+
+            // Exécution de la fonction d'import (hypothétique)x
+            var blob = new Blob([csvStringToImport], {type: "text/csv"});
+            fs.writeFileSync('test.csv', csvStringToImport);
+            blob.path = 'test.csv';
+            blob.originalFilename = 'test.csv';
+
+            const result = await importData(impexTestModel.name, {file: blobToFile(blob,"test.csv")}, '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
+
+            // Vérifier que seule les données valides sont en BDD
+            const count = await testDatasColInstance.countDocuments({ _model: impexTestModel.name });
+            expect(count).toBe(3);
+        });
+    });
+});

package/test/workflow.integration.test.js

@@ -0,0 +1,314 @@
+// __tests__/workflow.integration.test.js
+import { expect, describe, it, beforeEach,afterEach, beforeAll, afterAll, vi } from 'vitest';
+import { Config } from "data-primals-engine/config";
+
+import {insertData, editData, deleteData, patchData} from 'data-primals-engine/modules/data';
+import { modelsCollection as getAppModelsCollection, getCollectionForUser } from 'data-primals-engine/modules/mongodb';
+import * as workflowModule from 'data-primals-engine/modules/workflow';
+import {getUniquePort, initEngine} from "../src/setenv.js";
+import process from "process";
+
+
+beforeAll(async () =>{
+    Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
+    await initEngine();
+})
+vi.mock('data-primals-engine/modules/workflow', { spy: true })
+// --- Données Mock pour les tests ---
+const mockUser = {
+    username: 'testuserWorkflow',
+    _user: 'testuserWorkflow',
+    userPlan: 'free',
+    email: 'testWorkflow@example.com'
+};
+
+// --- Définitions des modèles ---
+
+// Le modèle de données qui déclenchera les workflows
+const targetDataModel = {
+    name: 'project',
+    _user: mockUser.username,
+    description: 'Un modèle pour les projets qui déclencheront des workflows',
+    fields: [
+        { name: 'projectName', type: 'string', required: true },
+        { name: 'status', type: 'string', required: true }, // ex: 'new', 'active', 'archived'
+        { name: 'budget', type: 'number' }
+    ],
+};
+
+// Les modèles qui définissent le système de workflow lui-même.
+// Pour les tests, nous devons insérer leurs définitions dans la collection 'models',
+// puis leurs instances (ex: un trigger spécifique) dans la collection 'datas' de l'utilisateur.
+// Les modèles qui définissent le système de workflow lui-me.
+// Pour les tests, nous devons insérer leurs définitions dans la collection 'models',
+// puis leurs instances (ex: un trigger spécifique) dans la collection 'datas' de l'utilisateur.
+const workflowMetaModels = [
+    {
+        name: 'workflow',
+        _user: mockUser.username,
+        description:'',
+        fields: [
+            { name: 'name', type: 'string' },
+            { name: 'startStep', type: 'relation', relation: 'workflowStep' }
+        ]
+    },
+    {
+        name: 'workflowStep',
+        _user: mockUser.username,
+        description:'',
+        fields: [
+            { name: 'name', type: 'string' },
+            { name: 'onSuccessStep', type: 'relation', relation: 'workflowStep' },
+            { name: 'onFailureStep', type: 'relation', relation: 'workflowStep' },
+            { name: 'isTerminal', type: 'boolean' },
+            { name: 'actions', type: 'array', itemsType: 'relation', relation: 'workflowAction' },
+            { name: 'conditions', type: 'object' }
+        ]
+    },
+    {
+        name: 'workflowTrigger',
+        _user: mockUser.username,
+        description:'',
+        fields: [
+            { name: 'name', type: 'string' },
+            { name: 'targetModel', type: 'model' },
+            { name: 'onEvent', type: 'enum', items: ['DataAdded', 'DataEdited', 'DataDeleted', 'ModelAdded', 'ModelEdited', 'ModelDeleted'] },
+            { name: 'isActive', type: 'boolean' },
+            { name: 'dataFilter', type: 'object' },
+            { name: 'workflow', type: 'relation', relation: 'workflow' },
+            { name: 'cronExpression', type: 'cronSchedule' },
+            { name: 'lockDurationMinutes', type: 'number' }
+        ]
+    },
+    {
+        name: 'workflowRun',
+        _user: mockUser.username,
+        description:'',
+        fields: [
+            { name: 'status', type: 'enum', items: ['pending', 'running', 'completed', 'failed', 'cancelled'] },
+            { name: 'workflow', type: 'relation', relation: 'workflow' },
+            { name: 'contextData', type: 'object' },
+            { name: 'currentStep', type: 'relation', relation: 'workflowStep' },
+            { name: 'error', type: 'string' },
+            { name: 'startedAt', type: 'datetime' },
+            { name: 'completedAt', type: 'datetime' },
+            { name: 'stepExecutionsCount', type: 'object' }
+        ]
+    },
+    {
+        name: 'workflowAction',
+        _user: mockUser.username,
+        description:'',
+        fields: [
+            // Common
+            { name: 'name', type: 'string' },
+            { name: 'type', type: 'enum', items: ['Webhook', 'CreateData', 'UpdateData', 'DeleteData', 'GenerateAIContent', 'SendEmail'] },
+            // Webhook
+            { name: 'url', type: 'url' },
+            { name: 'method', type: 'enum', items: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'] },
+            { name: 'headers', type: 'code', language: 'json' },
+            { name: 'body', type: 'code', language: 'json' },
+            // Create/Update/Delete
+            { name: 'targetModel', type: 'model' },
+            { name: 'dataToCreate', type: 'code', language: 'json' },
+            { name: 'targetSelector', type: 'code', language: 'json' },
+            { name: 'fieldsToUpdate', type: 'code', language: 'json' },
+            { name: 'updateMultiple', type: 'boolean' },
+            { name: 'deleteMultiple', type: 'boolean' },
+            // GenerateAIContent
+            { name: 'aiProvider', type: 'enum', items: ['OpenAI', 'GoogleGemini'] },
+            { name: 'aiModel', type: 'string' },
+            { name: 'prompt', type: 'richtext' },
+            // SendEmail
+            { name: 'emailRecipients', type: 'array', itemsType: 'string' },
+            { name: 'emailSubject', type: 'string' },
+            { name: 'emailContent', type: 'richtext' }
+        ]
+    }
+];
+
+
+let testModelsColInstance;
+let testDatasColInstance;
+let engineInstance;
+
+const port = process.env.PORT || getUniquePort(); // Port différent
+
+// On "espionne" `c` pour vérifier qu'elle est appelée sans l'exécuter réellement.
+// Cela nous permet de tester uniquement la logique de déclenchement.
+const processWorkflowRunSpy = vi.spyOn(workflowModule, 'processWorkflowRun');
+
+beforeEach(async () => {
+    testModelsColInstance = getAppModelsCollection;
+    testDatasColInstance = getCollectionForUser(mockUser);
+    // Nettoyer les données avant chaque test
+    await testDatasColInstance.deleteMany({_user: "testuserWorkflow"});
+
+    // Réinitialiser l'espion
+    processWorkflowRunSpy.mockClear();
+
+    const mods = await testModelsColInstance.find({ $and: [{ _user: mockUser.username}, { $or: [{name: targetDataModel.name}, ...workflowMetaModels.map(m =>({name: m.name}))]}]}).toArray();
+    if( mods.length === 0 ) {
+        // Insérer les définitions de modèles nécessaires
+        await testModelsColInstance.insertMany([
+            {...targetDataModel},
+            ...workflowMetaModels.map(m => ({...m})) // Copie pour éviter les mutations
+        ]);
+    }
+    console.log({mods})
+});
+
+describe('Intégration des Workflows - triggerWorkflows', () => {
+
+    let testWorkflow;
+    let testStep;
+
+    // Avant chaque test de ce bloc, on crée un workflow et une étape de base
+    const initTest = async () => {
+        const workflowInsertResult = await insertData('workflow', { name: 'Test Workflow' }, {}, mockUser, false);
+        testWorkflow = { _id: workflowInsertResult.insertedIds[0] };
+
+        const stepInsertResult = await insertData('workflowStep', { name: 'Start Step', isTerminal: true }, {}, mockUser, false);
+        testStep = { _id: stepInsertResult.insertedIds[0] };
+
+        // Lier l'étape au workflow
+        await editData('workflow', testWorkflow._id, { startStep: testStep._id.toString() }, {}, mockUser, false);
+    };
+
+    it('devrait créer un workflowRun lors de l\'ajout de données correspondant à un trigger "DataAdded"', async () => {
+        await initTest();
+        // 1. Arrange: Créer un déclencheur actif pour 'DataAdded' sur le modèle 'project'
+        await insertData('workflowTrigger', {
+            name: 'Trigger on Project Add',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataAdded',
+            isActive: true,
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Insérer une donnée qui doit déclencher le workflow
+        const projectData = { projectName: 'New Corp Website', status: 'new', budget: 50000 };
+        const insertResult = await insertData(targetDataModel.name, projectData, {}, mockUser, true, true);
+
+        expect(insertResult.success).toBe(true);
+
+        const workflowRun = await testDatasColInstance.findOne({ _model: 'workflowRun' });
+
+        expect(workflowRun).not.toBeNull();
+        expect(workflowRun.status).toBe('completed');
+        expect(workflowRun.workflow.toString()).toBe(testWorkflow._id.toString());
+        expect(workflowRun.contextData.triggerData._id.toString()).toBe(insertResult.insertedIds[0].toString());
+        expect(workflowRun.contextData.triggerData.projectName).toBe('New Corp Website');
+
+    });
+
+    it('ne devrait PAS créer de workflowRun si le trigger est inactif', async () => {
+        await initTest();
+        // 1. Arrange: Créer un déclencheur INACTIF
+        await insertData('workflowTrigger', {
+            name: 'Inactive Trigger',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataAdded',
+            isActive: false, // Inactif
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Insérer des données
+        await insertData(targetDataModel.name, { projectName: 'Secret Project', status: 'new' }, {}, mockUser, true);
+
+        // 3. Assert: Aucun `workflowRun` ne doit être créé
+        const workflowRunCount = await testDatasColInstance.countDocuments({ _model: 'workflowRun' });
+        expect(workflowRunCount).toBe(0);
+    });
+
+    it('devrait créer un workflowRun si le dataFilter est satisfait', async () => {
+        await initTest();
+        // 1. Arrange: Créer un déclencheur avec un `dataFilter`
+        await insertData('workflowTrigger', {
+            name: 'Trigger for Active Projects',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataAdded',
+            isActive: true,
+            dataFilter: { $eq: ['$status', 'active'] }, // Filtre pour status = 'active'
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Insérer des données qui correspondent au filtre
+        await insertData(targetDataModel.name, { projectName: 'Go-Live Project', status: 'active' }, {}, mockUser, true, true);
+
+        // 3. Assert: Un `workflowRun` doit être créé
+        const workflowRunCount = await testDatasColInstance.countDocuments({ _model: 'workflowRun' });
+        expect(workflowRunCount).toBe(1);
+    });
+
+    it('ne devrait PAS créer de workflowRun si le dataFilter n\'est PAS satisfait', async () => {
+        await initTest();
+        // 1. Arrange: Créer un déclencheur avec un `dataFilter`
+        await insertData('workflowTrigger', {
+            name: 'Trigger for Archived Projects',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataAdded',
+            isActive: true,
+            dataFilter: { $eq: ['$status', 'archived'] }, // Filtre pour status = 'archived'
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Insérer des données qui NE correspondent PAS au filtre
+        await insertData(targetDataModel.name, { projectName: 'Ongoing Project', status: 'active' }, {}, mockUser, true, true);
+
+        // 3. Assert: Aucun `workflowRun` ne doit être créé
+        const workflowRunCount = await testDatasColInstance.countDocuments({ _model: 'workflowRun' });
+        expect(workflowRunCount).toBe(0);
+    });
+
+    it('devrait déclencher un workflow "DataEdited" lors de la modification de données', async () => {
+        await initTest();
+        // 1. Arrange: Insérer une donnée initiale et un déclencheur pour 'DataEdited'
+        const insertResult = await insertData(targetDataModel.name, { projectName: 'To Edit', status: 'initial' }, {}, mockUser, false);
+        const projectId = insertResult.insertedIds[0];
+
+        await insertData('workflowTrigger', {
+            name: 'Trigger on Project Edit',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataEdited',
+            isActive: true,
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Modifier la donnée
+        const editResult = await patchData(targetDataModel.name, projectId, { status: 'edited' }, {}, mockUser, true, true);
+        expect(editResult.success).toBe(true);
+
+        // 2. Act: Modifier la donnée
+        const editResult2 = await editData(targetDataModel.name, projectId, { projectName: 'test', status: 'edited' }, {}, mockUser, true, true);
+        expect(editResult2.success).toBe(true);
+
+        const workflows = await testDatasColInstance.countDocuments({ _model: 'workflowRun' });
+        expect(workflows).toBe(2);
+    });
+
+    it('devrait déclencher un workflow "DataDeleted" lors de la suppression de données', async () => {
+        await initTest();
+        // 1. Arrange: Insérer une donnée et un déclencheur pour 'DataDeleted'
+        const insertResult = await insertData(targetDataModel.name, { projectName: 'To Delete', status: 'temp' }, {}, mockUser, false);
+        const projectId = insertResult.insertedIds[0];
+
+        await insertData('workflowTrigger', {
+            name: 'Trigger on Project Delete',
+            targetModel: targetDataModel.name,
+            onEvent: 'DataDeleted',
+            isActive: true,
+            workflow: testWorkflow._id.toString()
+        }, {}, mockUser, false);
+
+        // 2. Act: Supprimer la donnée
+        const deleteResult = await deleteData(targetDataModel.name, [projectId], {}, mockUser, true, true);
+        expect(deleteResult.success).toBe(true);
+
+        // 3. Assert: Un `workflowRun` doit être créé
+        const workflowRun = await testDatasColInstance.findOne({ _model: 'workflowRun' });
+        expect(workflowRun).not.toBeNull();
+        // Le `triggerData` est le document *avant* sa suppression
+        expect(workflowRun.contextData.triggerData.projectName).toBe('To Delete');
+    });
+});