data-primals-engine 1.0.8 → 1.0.10

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/model.integration.test.js

@@ -0,0 +1,219 @@
+// __tests__/data.integration.test.js
+import { ObjectId } from 'mongodb';
+import {expect, describe, it, beforeEach, afterEach, beforeAll, afterAll, vi} from 'vitest';
+import { Config } from '../src/config.js';
+
+import {
+    modelsCollection as getAppModelsCollection,
+    datasCollection // 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";
+
+let testModelsColInstance;
+let testDatasColInstance;
+
+let testModelId;
+
+// 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',
+        email: generateUniqueName('test') + '@example.com'
+    };
+
+
+    const relatedModelDefinition = {
+        name: currentRelatedModelName,
+        _user: currentTestUser.username,
+        description: 'Model for testing relations',
+        fields: [
+            {name: 'relatedName', type: 'string', required: true, unique: true},
+            {name: 'relatedValue', type: 'number'}
+        ],
+        maxRequestData: 10,
+    };
+
+    const comprehensiveTestModelDefinition = {
+        name: currentTestModelName,
+        _user: currentTestUser.username,
+        description: 'A model with all field types and constraints for testing',
+        fields: [
+            // String types
+            {name: 'stringRequired', type: 'string', required: true, hint: 'A required string'},
+            {name: 'stringUnique', type: 'string', unique: true, hint: 'A unique string'},
+            {name: 'stringMaxLength', type: 'string', maxlength: 5, hint: 'String with max length 5'},
+            {name: 'stringDefault', type: 'string', default: 'defaultString'},
+            {name: 'string_tLang', type: 'string_t', hint: 'Localizable string'},
+            {name: 'richtextField', type: 'richtext', maxlength: 200},
+            {name: 'passwordField', type: 'password'},
+            {name: 'emailField', type: 'email'},
+            {name: 'phoneField', type: 'phone'},
+            {name: 'urlField', type: 'url'},
+            // Number types
+            {name: 'number', type: 'number'},
+            {name: 'numberMinMax', type: 'number', min: 10, max: 20},
+            {name: 'numberStep', type: 'number', step: 0.5},
+            {name: 'numberDefault', type: 'number', default: 42},
+            // Boolean
+            {name: 'booleanField', type: 'boolean'},
+            {name: 'booleanDefault', type: 'boolean', default: true},
+            // Date & Datetime
+            {name: 'dateField', type: 'date'},
+            {name: 'datetimeField', type: 'datetime', default: 'now'},
+            {name: 'dateMinMax', type: 'date', min: '2023-01-01', max: '2023-12-31'},
+            // Enum
+            {name: 'enumField', type: 'enum', items: ['alpha', 'beta', 'gamma']},
+            {name: 'enumDefault', type: 'enum', items: ['one', 'two'], default: 'one'},
+            // Array
+            {name: 'arrayString', type: 'array', itemsType: 'string', maxItems: 2},
+            {name: 'arrayNumber', type: 'array', itemsType: 'number', minItems: 1},
+            {name: 'arrayEnum', type: 'array', itemsType: 'enum', items: ['a', 'b']},
+            // Relation
+            {name: 'relationSingle', type: 'relation', relation: currentRelatedModelName},
+            {name: 'relationMultiple', type: 'relation', relation: currentRelatedModelName, multiple: true},
+            // File (metadata validation)
+            {name: 'fileField', type: 'file', mimeTypes: ['image/png', 'application/pdf'], maxSize: 1024 * 10}, // 10KB
+            // Color
+            {name: 'colorField', type: 'color'},
+            // Code
+            {name: 'codeJsonField', type: 'code', language: 'json'},
+            {name: 'codeJsField', type: 'code', language: 'javascript', maxlength: 100},
+            // Object (simple validation, structure not deeply validated by default dataTypes.object)
+            {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'}
+        ],
+        maxRequestData: 50,
+    };
+
+    // Insérer les modèles en base
+    const result=  await testModelsColInstance.insertMany([
+        comprehensiveTestModelDefinition,
+        relatedModelDefinition
+    ]);
+
+    testModelId = result.insertedIds[0];
+    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,
+        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 () => {
+            // --- SETUP ---
+            const { currentTestUser, comprehensiveTestModelDefinition } = await setupTestContext();
+            const premiumUser = { ...currentTestUser, userPlan: 'premium' };
+            const dataCollection = getCollectionForUser(premiumUser);
+            const fieldToIndex = 'stringUnique'; // Utiliser un champ qui existe vraiment dans le modèle
+
+            // --- 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
+                }
+            }
+            expect(initialIndexes.some(i => i.key[fieldToIndex] === 1)).toBe(false);
+
+            // --- ACTION 1 : AJOUTER UN INDEX ---
+            const modelWithIndex = {
+                ...comprehensiveTestModelDefinition,
+                fields: comprehensiveTestModelDefinition.fields.map(f =>
+                    f.name === fieldToIndex ? { ...f, index: true } : f
+                ),
+            };
+            await editModel(premiumUser, testModelId, modelWithIndex);
+
+            // --- VERIFICATION 1 ---
+            // Maintenant, la collection et l'index doivent exister.
+            const indexesAfterCreation = await dataCollection.indexes();
+            const newIndex = indexesAfterCreation.find(i => i.key[fieldToIndex] === 1);
+
+            expect(newIndex).toBeDefined();
+            // 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,
+            });
+
+            // --- ACTION 2 : SUPPRIMER L'INDEX ---
+            const modelWithoutIndex = {
+                ...comprehensiveTestModelDefinition,
+                fields: comprehensiveTestModelDefinition.fields.map(f =>
+                    f.name === fieldToIndex ? { ...f, index: false } : f
+                ),
+            };
+            await editModel(premiumUser, 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
+
+        it('should not save extra, non-defined fields in the model definition', async () => {
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            // 1. Préparer les données avec un champ non sollicité
+            const updatedModelData = {
+                ...comprehensiveTestModelDefinition,
+                description: 'An updated description',
+                extraBogusField: 'this should not be saved', // Champ arbitraire
+                anotherOne: { nested: true }
+            };
+            // 2. Appeler la fonction d'édition
+            const result = await editModel(currentTestUser, testModelId, updatedModelData);
+            expect(result.success).toBe(false);
+        });
+        it('should return an error if trying to edit a non-existent model', async () => {
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            const nonExistentId = new ObjectId();
+            const result = await editModel(currentTestUser, nonExistentId, comprehensiveTestModelDefinition);
+            expect(result.success).toBe(false);
+            expect(result.statusCode).toBe(404);
+            expect(result.error).toContain('introuvable');
+        });
+        it('should return an error if the new model structure is invalid', async () => {
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await setupTestContext();
+            const invalidModelData = {
+                ...comprehensiveTestModelDefinition,
+                fields: [
+                    { name: 'title' } // Le champ 'type' est manquant, ce qui est invalide
+                ]
+            };
+            const result = await editModel(currentTestUser, testModelId, invalidModelData);
+            expect(result.success).toBe(false);
+            // L'erreur est levée par validateModelStructure, donc le message peut varier
+            expect(result.error).toBeDefined();
+        });
+    });
+
+});