data-primals-engine 1.1.8 → 1.2.1

package/test/data.integration.test.js

@@ -471,7 +471,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const insertResult = await insertData(simpleModel.name, dataToDelete, {}, currentTestUser, false);
             const docId = insertResult.insertedIds[0];
 
-            const deleteResult = await deleteData(simpleModel.name, [docId], {}, currentTestUser, false);
+            const deleteResult = await deleteData(simpleModel.name, [docId], currentTestUser);
 
             expect(deleteResult.success).toBe(true);
             expect(deleteResult.deletedCount).toBe(1);
@@ -493,7 +493,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
                 input: '$name',
                 regex: "^Item Filtrable"
             } };
-            const deleteResult = await deleteData(simpleModel.name, [], filter, currentTestUser, false);
+            const deleteResult = await deleteData(simpleModel.name, filter, currentTestUser);
 
             expect(deleteResult.success).toBe(true);
             expect(deleteResult.deletedCount).toBe(2);
@@ -551,19 +551,16 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         it('devrait trouver un document par une condition sur une relation simple ($find)', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
             const searchParams = {
-                user: currentTestUser,
-                query: {
-                    model: comprehensiveTestModelDefinition.name,
-                    filter: {
-                        relationSingle: {
-                            "$find": { "$and": [{"$eq": ["$$this.relatedValue", 101]}] }
-                        }
-                    },
-                    autoExpand: true,
-                    depth: 8
-                }
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    relationSingle: {
+                        "$find": { "$and": [{"$eq": ["$$this.relatedValue", 101]}] }
+                    }
+                },
+                autoExpand: true,
+                depth: 8
             };
-            const { data, count } = await searchData(searchParams);
+            const { data, count } = await searchData(searchParams, currentTestUser);
             expect(count).toBe(1);
             expect(data).toHaveLength(1);
             expect(data[0]._id.toString()).toBe(docId1.toString());
@@ -575,18 +572,15 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         it('ne devrait pas trouver de document si la condition $find sur relation simple ne correspond pas', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
             const searchParams = {
-                user: currentTestUser,
-                query: {
-                    model: comprehensiveTestModelDefinition.name,
-                    filter: {
-                        relationSingle: {
-                            "$find": { "$eq": ["$$this.relatedName", "NonExistentRelName"] }
-                        }
-                    },
-                    depth: 1
-                }
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    relationSingle: {
+                        "$find": { "$eq": ["$$this.relatedName", "NonExistentRelName"] }
+                    }
+                },
+                depth: 1
             };
-            const { data, count } = await searchData(searchParams);
+            const { data, count } = await searchData(searchParams, currentTestUser);
             expect(count).toBe(0);
             expect(data).toHaveLength(0);
         });
@@ -594,20 +588,17 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         it('devrait trouver des documents par une condition sur une relation multiple ($find)', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
             const searchParams = {
-                user: currentTestUser,
-                query: {
-                    model: comprehensiveTestModelDefinition.name,
-                    filter: {
-                        $and: [{$ne:["$stringRequired", null]}, {
-                            relationMultiple: { // Le champ qui est un tableau de relations
-                                "$find": {"$eq": ["$$this.relatedValue", 102]} // Condition sur les documents liés
-                            }
-                        }]
-                    },
-                    depth: 1
-                }
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    $and: [{$ne:["$stringRequired", null]}, {
+                        relationMultiple: { // Le champ qui est un tableau de relations
+                            "$find": {"$eq": ["$$this.relatedValue", 102]} // Condition sur les documents liés
+                        }
+                    }]
+                },
+                depth: 1
             };
-            const { data, count } = await searchData(searchParams);
+            const { data, count } = await searchData(searchParams, currentTestUser);
             expect(count).toBe(1);
             expect(data).toHaveLength(1);
             expect(data[0]._id.toString()).toBe(docId1.toString());
@@ -620,19 +611,16 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         it('devrait trouver des documents en combinant un filtre normal et un filtre $find', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
             const searchParams = {
-                user: currentTestUser,
-                query: {
-                    model: comprehensiveTestModelDefinition.name,
-                    filter: {
-                        stringRequired: "SearchDoc1", // Filtre sur le modèle principal
-                        relationSingle: {
-                            "$find": {"$gt": ["$$this.relatedValue", 100] } // Filtre sur la relation
-                        }
-                    },
-                    depth: 1
-                }
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    stringRequired: "SearchDoc1", // Filtre sur le modèle principal
+                    relationSingle: {
+                        "$find": {"$gt": ["$$this.relatedValue", 100] } // Filtre sur la relation
+                    }
+                },
+                depth: 1
             };
-            const { data, count } = await searchData(searchParams);
+            const { data, count } = await searchData(searchParams,currentTestUser);
             expect(count).toBe(1);
             expect(data).toHaveLength(1);
             expect(data[0]._id.toString()).toBe(docId1.toString());
@@ -641,26 +629,21 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         it('devrait retourner un tableau vide si $find ne correspond à aucun document lié', async () => {
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition } = await initTest();
             const searchParams = {
-                user: currentTestUser,
-                query: {
-                    model: comprehensiveTestModelDefinition.name,
-                    filter: {
-                        relationMultiple: {
-                            "$find": { "$eq": ["$$this.relatedName", "NonExistentRelNameForMultiple"] }
-                        }
-                    },
-                    depth: 1
-                }
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    relationMultiple: {
+                        "$find": { "$eq": ["$$this.relatedName", "NonExistentRelNameForMultiple"] }
+                    }
+                },
+                depth: 1
             };
-            const { data, count } = await searchData(searchParams);
+            const { data, count } = await searchData(searchParams,currentTestUser);
             expect(count).toBe(0);
             expect(data).toHaveLength(0);
         });
 
     });
 
-    // Dans C:/Dev/hackersonline-engine/test/data.integration.test.js
-
     describe('installPack', () => {
         let testPacksColInstance;
 
@@ -824,8 +807,8 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             // Cleanup before starting to ensure a clean state
             await deleteModels({ name: productModel.name, _user: user.username });
             await deleteModels({ name: orderModel.name, _user: user.username });
-            await deleteData(productModel.name, [], {}, user);
-            await deleteData(orderModel.name, [], {}, user);
+            await deleteData(productModel.name, {}, user);
+            await deleteData(orderModel.name, {}, user);
 
             // Create models
             await createModel({ ...productModel, _user: user.username });
@@ -843,8 +826,8 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         afterAll(async () => {
             await deleteModels({ name: productModel.name, _user: user.username });
             await deleteModels({ name: orderModel.name, _user: user.username });
-            await deleteData(productModel.name, [], {}, user);
-            await deleteData(orderModel.name, [], {}, user);
+            await deleteData(productModel.name, {}, user);
+            await deleteData(orderModel.name, {}, user);
         });
 
         it('should ALLOW inserting data with a valid relation', async () => {
@@ -852,7 +835,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(result.success).toBe(true);
             expect(result.insertedIds).toHaveLength(1);
             // Cleanup the created order for test isolation
-            await deleteData(orderModel.name, result.insertedIds, {}, user);
+            await deleteData(orderModel.name, result.insertedIds, user);
         });
 
         it('should REJECT inserting data with a relation that does not respect the filter', async () => {
@@ -873,7 +856,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(result.modifiedCount).toBeGreaterThanOrEqual(0);
 
             // Cleanup
-            await deleteData(orderModel.name, initialOrder.insertedIds, {}, user);
+            await deleteData(orderModel.name, initialOrder.insertedIds, user);
         });
 
         it('should REJECT updating data with a relation that does not respect the filter', async () => {
@@ -885,7 +868,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             expect(result.success).toBe(false);
             expect(result.error).toContain('produit');
             // Cleanup
-            await deleteData(orderModel.name, initialOrder.insertedIds, {}, user);
+            await deleteData(orderModel.name, initialOrder.insertedIds, user);
         });
     });
 });

package/test/user.test.js

@@ -0,0 +1,203 @@
+import { expect, describe, it, beforeEach, beforeAll, afterAll } from 'vitest';
+import { hasPermission, getUserActivePermissions } from '../src/modules/user.js';
+import {initEngine} from "data-primals-engine/setenv";
+import {generateUniqueName} from "../src/setenv.js";
+import {
+    getCollectionForUser as getAppUserCollection,
+    modelsCollection as getAppModelsCollection
+} from "data-primals-engine/modules/mongodb";
+import {Config} from "../src/index.js";
+let permRead, permWrite, permDelete, permManage;
+let roleEditor;
+let testUser, adminUser, roleViewer;
+let currentTestUser;
+let testModelsColInstance, testDatasColInstance;
+// Cette fonction va remplacer la logique de votre beforeEach pour la création de contexte
+async function setupTestContext() {
+
+
+    // Créer un utilisateur unique pour ce test
+    const username = generateUniqueName('testuserDataIntegration');
+    currentTestUser = {
+        username,
+        userPlan: 'free',
+        _model: 'user',
+        _user: username,
+        email: generateUniqueName('test') + '@example.com'
+    };
+
+    // Initialize collection instances after the engine is ready
+    testModelsColInstance = getAppModelsCollection;
+    testDatasColInstance = await getAppUserCollection(currentTestUser);
+
+    await testDatasColInstance.deleteMany({}); // Nettoyage de la base de test
+    // 1. Créer les permissions
+    const permissions = await testDatasColInstance.insertMany([
+        { _model: 'permission', name: 'post:read', description: 'Lire les articles' },
+        { _model: 'permission', name: 'post:write', description: 'Écrire des articles' },
+        { _model: 'permission', name: 'post:delete', description: 'Supprimer des articles' },
+        { _model: 'permission', name: 'user:manage', description: 'Gérer les utilisateurs' }
+    ]);
+    permRead = permissions.insertedIds[0];
+    permWrite = permissions.insertedIds[1];
+    permDelete = permissions.insertedIds[2];
+    permManage = permissions.insertedIds[3];
+
+    // 2. Créer les rôles
+    const roles = await testDatasColInstance.insertMany([
+        { _user: currentTestUser.username, _model: 'role', name: 'Viewer', permissions: [permRead.toString()] },
+        { _user: currentTestUser.username, _model: 'role', name: 'Editor', permissions: [permRead.toString(), permWrite.toString()] }
+    ]);
+    roleViewer = roles.insertedIds[0];
+    roleEditor = roles.insertedIds[1];
+
+    // 3. Créer les utilisateurs
+    const users = await testDatasColInstance.insertMany([
+        { _user: currentTestUser.username, _model: 'user', roles: [roleEditor.toString()] },
+        { _user: currentTestUser.username, _model: 'user', roles: [roleEditor.toString()] }
+    ]);
+    testUser = {...currentTestUser, _id: users.insertedIds[0].toString(), roles: [roleEditor.toString()] };
+    adminUser = {...currentTestUser,  _id: users.insertedIds[1].toString(), roles: [roleEditor.toString()] };
+};
+let engine;
+describe('User Permission Logic', () => {
+
+    // --- SETUP : Création des données de test avant tous les tests ---
+    beforeAll(async () => {
+        Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
+        engine = await initEngine();
+
+    });
+
+    // --- Tests pour la fonction principale de calcul ---
+    describe('getUserActivePermissions()', () => {
+
+
+        beforeEach(async () =>{
+            await setupTestContext();
+        })
+        it('should return base permissions from the user\'s role', async () => {
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions).to.be.an.instanceOf(Set);
+            expect(permissions.size).to.equal(2);
+            expect(permissions.has('post:read')).to.be.true;
+            expect(permissions.has('post:write')).to.be.true;
+            expect(permissions.has('post:delete')).to.be.false;
+        });
+
+        it('should grant a temporary permission via an exception', async () => {
+
+            // Ajoute une exception qui donne la permission de supprimer, expirant demain
+            const futureDate = new Date();
+            futureDate.setDate(futureDate.getDate() + 1);
+
+            await testDatasColInstance.insertOne({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permDelete,
+                isGranted: true,
+                expiresAt: futureDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions.size).to.equal(3);
+            expect(permissions.has('post:delete')).to.be.true;
+
+            // Nettoyage de l'exception pour ne pas affecter les autres tests
+            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+        });
+
+        it('should NOT grant an expired temporary permission', async () => {
+            // Ajoute une exception qui a expiré hier
+            const pastDate = new Date();
+            pastDate.setDate(pastDate.getDate() - 1);
+
+            await testDatasColInstance.insertOne({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permDelete,
+                isGranted: true,
+                expiresAt: pastDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions.size).to.equal(2); // Revient la normale
+            expect(permissions.has('post:delete')).to.be.false;
+
+            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+        });
+
+        it('should revoke a base permission via an exception', async () => {
+            // L'utilisateur est "Editor", mais on lui retire le droit d'écriture temporairement
+            const futureDate = new Date();
+            futureDate.setDate(futureDate.getDate() + 1);
+
+            await testDatasColInstance.insertOne({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permWrite,
+                isGranted: false, // Révocation
+                expiresAt: futureDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions.size).to.equal(1);
+            expect(permissions.has('post:read')).to.be.true;
+            expect(permissions.has('post:write')).to.be.false; // La permission a été retirée
+
+            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+        });
+
+        it('should restore a revoked permission if the revocation has expired', async () => {
+            // La révocation a expiré, l'utilisateur devrait retrouver son droit d'écriture
+            const pastDate = new Date();
+            pastDate.setDate(pastDate.getDate() - 1);
+
+            await testDatasColInstance.insertOne({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permWrite,
+                isGranted: false,
+                expiresAt: pastDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions.size).to.equal(2);
+            expect(permissions.has('post:write')).to.be.true; // La permission est de retour
+
+            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+        });
+    });
+
+    // --- Tests pour la fonction publique `hasPermission` ---
+    describe('hasPermission()', () => {
+        beforeEach(async () => {
+            await setupTestContext();
+        });
+        it('should return true for a permission the user has', async () => {
+
+
+            console.log(await testDatasColInstance.find({ _model: 'permission' }).toArray());
+            console.log(await testDatasColInstance.find({ _model: 'role' }).toArray());
+            console.log(await testDatasColInstance.find({ _model: 'user' }).toArray());
+            console.log(await testDatasColInstance.find({ _model: 'userPermission' }).toArray());
+            const result = await hasPermission('post:read', testUser);
+            expect(result).to.be.true;
+        });
+
+        it('should return false for a permission the user does not have', async () => {
+            const result = await hasPermission('user:manage', testUser);
+            expect(result).to.be.false;
+        });
+
+        it('should return true if user has at least one of the required permissions', async () => {
+            const result = await hasPermission(['user:manage', 'post:write'], testUser);
+            expect(result).to.be.true;
+        });
+
+        it('should return false if user has none of the required permissions', async () => {
+            const result = await hasPermission(['user:manage', 'post:delete'], testUser);
+            expect(result).to.be.false;
+        });
+    });
+});

package/test/workflow.integration.test.js

@@ -299,7 +299,7 @@ describe('Intégration des Workflows - triggerWorkflows', () => {
         }, {}, mockUser, false);
 
         // 2. Act: Supprimer la donnée
-        const deleteResult = await deleteData(targetDataModel.name, [projectId], {}, mockUser, true, true);
+        const deleteResult = await deleteData(targetDataModel.name, [projectId], mockUser, true, true);
         expect(deleteResult.success).toBe(true);
 
         // 3. Assert: Un `workflowRun` doit être créé