data-primals-engine 1.0.9 → 1.0.10

package/src/index.js

@@ -10,6 +10,6 @@ export { UserProvider } from './providers.js';
 
 // --- Database & Data Modules ---
 export { datasCollection, filesCollection, modelsCollection, packsCollection } from './modules/mongodb.js';
-export { searchData, insertData, editData, loadFromDump, dumpUserData, validateRestoreRequest, patchData, deleteData, createModel, getModel, getModels } from './modules/data.js';
+export { searchData, insertData, editData, exportData, importData, scheduleAlerts, cancelAlerts, validateModelStructure, installPack, jobDumpUserData, loadFromDump, dumpUserData, validateRestoreRequest, patchData, deleteData, createModel, editModel, deleteModels, getModel, getModels } from './modules/data.js';
 
 

package/src/modules/data.js

@@ -1113,6 +1113,111 @@ function applyCronMask(cronString, mask, defaults) {
     return newParts.join(' ');
 }
 
+
+export const editModel = async (user, id, data) => {
+
+    if( !(isDemoUser(user) && Config.Get("useDemoAccounts")) && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_EDIT_MODEL"], user)){
+        return ({success: false, error: i18n.t('api.permission.editModel', 'Cannot edit models from the API')})
+    }
+
+    const dataModel = data;
+    try {
+        const collection = getCollectionForUser(user);
+        validateModelStructure(dataModel);
+
+        const el = await modelsCollection.findOne({ $and: [
+                {_user: {$exists: true}},
+                { _id: new ObjectId(id) },
+                {$and: [{_user: {$exists: true}}, {$or: [{_user: user._user}, {_user: user.username}]}]
+                }
+            ]});
+
+        if( !el ){
+            return ({success: false, statusCode: 404, error: i18n.t("api.model.notFound", { model: dataModel.name })});
+        }
+
+        // renommage du modèle
+        if (typeof (data.name)==='string'&&el.name !== data.name && data.name ){
+            await collection.updateMany({ _model: el.name }, { $set: { _model: data.name }});
+            await modelsCollection.updateMany({ 'fields' : {
+                    '$elemMatch' : { relation: el.name }
+                }}, {
+                $set : {
+                    'fields.$.relation' : data.name
+                }
+            })
+        }
+
+        const coll = getCollectionForUser(user);
+        // Update indexes
+// Update indexes
+        if (user.userPlan === 'premium') {
+            let indexes = [];
+            try {
+                // On essaie de récupérer les index existants
+                indexes = await coll.indexes();
+            } catch (e) {
+                // Si la collection n'existe pas, c'est normal.
+                // createIndex la créera. Il n'y a juste pas d'index à supprimer.
+                if (e.codeName !== 'NamespaceNotFound') {
+                    throw e; // On relance les autres erreurs
+                }
+            }
+
+            // Le reste de votre logique de gestion d'index peut maintenant s'exécuter en toute sécurité
+            for (const field of data.fields) {
+                const elField = el.fields.find(f => f.name === field.name);
+                if (!elField) continue;
+
+                const index = indexes.find(i => i.key[field.name] === 1 &&
+                    i.partialFilterExpression?._model === el.name &&
+                    i.partialFilterExpression?._user === user.username);
+
+                if (elField.index !== field.index && !field.index) {
+                    if (index) {
+                        await coll.dropIndex(index.name);
+                    }
+                } else if (elField.index !== field.index && field.index) {
+                    if (!index) {
+                        await coll.createIndex({ [field.name]: 1 }, {
+                            partialFilterExpression: {
+                                _model: data.name,
+                                _user: user.username
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        // suppression des données à la suppression des champs
+        const unset = {};
+        el.fields.filter(f=> !dataModel.fields.some(dt => dt.name === f.name)).map(f => f.name).forEach(f => {
+            unset[f] = 1;
+        });
+        await collection.updateMany({ _model: el.name }, { $unset: unset });
+
+        // sauvegarde du modele
+        const set = {...data};
+        delete set['_id'];
+
+        const oid = new ObjectId(id);
+        await modelsCollection.updateOne({_id: oid}, {$set: set});
+
+        modelsCache.del(user.username+'@@'+el.name);
+
+        const model = await modelsCollection.findOne({_id: oid });
+        triggerWorkflows(model, user, 'ModelEdited').catch(workflowError => {
+            logger.error(`Erreur asynchrone lors du déclenchement des workflows pour ${model._model} ID ${model._id}:`, workflowError);
+        });
+
+        return ({ success: true, data: await modelsCollection.findOne({_id : oid}) });
+    } catch (e) {
+        logger.error(e);
+        return ({ success: false, error: e.message, statusCode: 500 });
+    }
+};
+
+
 export async function onInit(defaultEngine) {
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
@@ -1459,95 +1564,17 @@ export async function onInit(defaultEngine) {
     });
 
     engine.put('/api/model/:id', [middlewareAuthenticator, userInitiator, setTimeoutMiddleware(15000)], async (req, res) => {
-
-        if( !(isDemoUser(req.me) && Config.Get("useDemoAccounts")) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_EDIT_MODEL"], req.me)){
-            return res.status(403).json({success: false, error: i18n.t('api.permission.editModel', 'Cannot edit models from the API')})
-        }
-
-        const dataModel = req.fields;
-        try {
-            const collection = getCollectionForUser(req.me);
-            validateModelStructure(dataModel);
-
-            const el = await modelsCollection.findOne({ $and: [
-                {_user: {$exists: true}},
-                { _id: new ObjectId(req.params.id) },
-                {$and: [{_user: {$exists: true}}, {$or: [{_user: req.me._user}, {_user: req.me.username}]}]
-            }
-            ]});
-
-            if( !el ){
-                return res.status(404).json({error: i18n.t("api.model.notFound", { model: dataModel.name })});
-            }
-
-            // renommage du modèle
-            if (typeof (req.fields.name)==='string'&&el.name !== req.fields.name && req.fields.name ){
-                await collection.updateMany({ _model: el.name }, { $set: { _model: req.fields.name }});
-                await modelsCollection.updateMany({ 'fields' : {
-                    '$elemMatch' : { relation: el.name }
-                    }}, {
-                    $set : {
-                        'fields.$.relation' : req.fields.name
-                    }
-                })
-            }
-
-            // Update indexes
-            if( req.me.userPlan === 'premium') {
-                const indexes = await datasCollection.indexes();
-                for (const field of dataModel.fields) {
-                    const elField = el.fields.find(f => f.name === field.name);
-                    if (!elField)
-                        continue;
-                    const index = indexes.find(i => i.key[field.name] === 1 &&
-                        i.partialFilterExpression?._model === el.name &&
-                        i.partialFilterExpression?._user === req.me.username);
-                    if (elField.index !== field.index && !field.index) {
-                        if (index) {
-                            await datasCollection.dropIndex(index.name);
-                        }
-                    } else if (elField.index !== field.index && field.index) {
-                        if (!index) {
-                            await datasCollection.createIndex({[field.name]: 1}, {
-                                partialFilterExpression: {
-                                    _model: dataModel.name,
-                                    _user: req.me.username
-                                }
-                            });
-                        }
-                    }
-                }
-            }
-
-            // suppression des données à la suppression des champs
-            const unset = {};
-            el.fields.filter(f=> !dataModel.fields.some(dt => dt.name === f.name)).map(f => f.name).forEach(f => {
-                unset[f] = 1;
-            });
-            await collection.updateMany({ _model: el.name }, { $unset: unset });
-
-            // sauvegarde du modele
-            const set = {...req.fields};
-            delete set['_id'];
-            await modelsCollection.updateOne({_id: new ObjectId(req.params.id)}, {$set: set});
-
-            modelsCache.del(req.me.username+'@@'+el.name);
-
-            const model = await modelsCollection.findOne({_id: new ObjectId(req.params.id) });
-            triggerWorkflows(model, req.me, 'ModelEdited').catch(workflowError => {
-                logger.error(`Erreur asynchrone lors du déclenchement des workflows pour ${model._model} ID ${model._id}:`, workflowError);
-            });
-
-            res.json({ success: true, data: await modelsCollection.findOne({_id : new ObjectId(req.params.id)}) });
-        } catch (e) {
-            logger.error(e);
-            res.json({ success: false });
+        const result = await editModel(req.me, req.params.id, req.fields);
+        if( result.success){
+            return res.status(result.statusCode || '200').json(result);
+        }else{
+            return res.status(result.statusCode || '500').json(result);
         }
-    })
+    });
 
     engine.post('/api/data/restore', [throttle, middlewareAuthenticator, userInitiator,myFreePremiumAnonymousLimiter, setTimeoutMiddleware(60000)], async (req, res) => {
 
-        if (!((req.me?.roles || []).includes("admin"))) {
+        if (!((user?.roles || []).includes("admin"))) {
             return res.status(403).json({success: false, error: 'Cannot backup data. Contact an administrator to get back your data'})
         }
 

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();
+        });
+    });
+
+});