data-primals-engine 1.6.0 → 1.6.1

package/src/modules/user.js

@@ -108,7 +108,7 @@ export async function onInit(defaultEngine) {
  * @returns {Promise<Set<string>>} Un Set contenant les noms de toutes les permissions actives.
  * @private
  */
-export async function getUserActivePermissions(user) {
+export async function getUserActivePermissions(user, env = null) {
     const datasCollection = await getCollectionForUser(user);
     const now = new Date();
     const activePermissions = new Set();
@@ -139,12 +139,17 @@ export async function getUserActivePermissions(user) {
     // --- ÉTAPE 2: Appliquer les exceptions de permission ---
     const exceptions = await datasCollection.aggregate([
         {
-            $match: {
+            $match: { // Filtre de base pour les exceptions de l'utilisateur
                 _model: "userPermission",
-                user: user._id, // Pas besoin de convertir en ObjectId si c'est déjà une string
-                $or: [
-                    { expiresAt: { $exists: false } },
-                    { expiresAt: { $gt: now } }
+                user: user._id,
+                $and: [ // Filtre sur l'environnement et l'expiration
+                    {
+                        $or: [ // La permission est soit globale, soit spécifique à l'environnement demandé
+                            { env: { $exists: false } },
+                            { env: env }
+                        ]
+                    },
+                    { $or: [{ expiresAt: { $exists: false } }, { expiresAt: { $gt: now } }] }
                 ]
             }
         },
@@ -193,7 +198,7 @@ export async function getUserActivePermissions(user) {
  * @param {object} user - L'objet utilisateur authentifié.
  * @returns {Promise<boolean>} - True si l'utilisateur a la permission, sinon false.
  */
-export async function hasPermission(permissionNames, user) {
+export async function hasPermission(permissionNames, user, env = null) {
     // Garde la compatibilité pour les utilisateurs non-locaux (ex: système)
     if (!isLocalUser(user)) {
         const userRoles = new Set(user.roles || []);
@@ -209,10 +214,10 @@ export async function hasPermission(permissionNames, user) {
         }
 
         // 1. Obtenir l'ensemble final et à jour des permissions de l'utilisateur
-        const activePermissions = await getUserActivePermissions(user);
+        const activePermissions = await getUserActivePermissions(user, env);
 
         // 2. Vérifier si au moins une des permissions requises est dans l'ensemble des permissions actives
-        return requiredPermissions.some(pName => activePermissions.has(pName));
+        return requiredPermissions.some(pName => activePermissions.has(pName)) || false;
 
     } catch (e) {
         logger.error("Erreur lors de la vérification des permissions :", e);

package/test/data.integration.test.js

@@ -1204,4 +1204,79 @@ describe('Data integration tests (CRUD, validation...)', () => {
         });
     });
 
+    describe('searchData avec filtre _env', () => {
+        let user, testModel, noEnvDocId;
+
+        beforeAll(async () => {
+            // Setup
+            const context = await setupTestContext();
+            user = context.currentTestUser;
+            testModel = {
+                name: generateUniqueName('envTestModel'),
+                description: '',
+                _user: user.username,
+                fields: [{ name: 'title', type: 'string' }]
+            };
+            await createModel(testModel);
+
+            // Insert test data
+            await insertData(testModel.name, { title: 'Prod Data', _env: 'prod' }, {}, user, false);
+            await insertData(testModel.name, { title: 'Staging Data', _env: 'staging' }, {}, user, false);
+            const noEnvResult = await insertData(testModel.name, { title: 'No Env Data' }, {}, user, false);
+            noEnvDocId = noEnvResult.insertedIds[0];
+        });
+
+        afterAll(async () => {
+            // Cleanup
+            await deleteModels({ name: testModel.name, _user: user.username });
+            await deleteData(testModel.name, {}, user);
+        });
+
+        it('devrait trouver uniquement les données avec _env="prod"', async () => {
+            const { data, count } = await searchData({
+                model: testModel.name,
+                env: 'prod'
+            }, user);
+            expect(count).toBe(1);
+            expect(data).toHaveLength(1);
+            expect(data[0].title).toBe('Prod Data');
+        });
+
+        it('devrait trouver uniquement les données avec _env="staging"', async () => {
+            const { data, count } = await searchData({
+                model: testModel.name,
+                env: 'staging'
+            }, user);
+            expect(count).toBe(1);
+            expect(data).toHaveLength(1);
+            expect(data[0].title).toBe('Staging Data');
+        });
+
+        it('devrait trouver uniquement les données SANS _env spécifié', async () => {
+            const { data, count } = await searchData({
+                model: testModel.name
+                // _env est omis intentionnellement
+            }, user);
+            expect(count).toBe(1);
+            expect(data).toHaveLength(1);
+            expect(data[0].title).toBe('No Env Data');
+        });
+
+        it('ne devrait trouver aucune donnée pour un _env inexistant', async () => {
+            const { data, count } = await searchData({
+                model: testModel.name,
+                env: 'nonexistent'
+            }, user);
+            expect(count).toBe(0);
+            expect(data).toHaveLength(0);
+        });
+
+        it('devrait permettre de modifier le champ _env via editData', async () => {
+            const result = await editData(testModel.name, { _id: noEnvDocId }, { _env: 'newly_assigned' }, {}, user);
+            expect(result.success).toBe(true);
+            const { data, count } = await searchData({ model: testModel.name, env: 'newly_assigned' }, user);
+            expect(count).toBe(1);
+            expect(data[0]._id.toString()).toBe(noEnvDocId.toString());
+        });
+    });
 });

package/test/user.test.js

@@ -1,4 +1,4 @@
-import { expect, describe, it, beforeEach, beforeAll, afterAll } from 'vitest';
+import { expect, describe, it, afterEach, beforeAll, afterAll } from 'vitest';
 import { hasPermission, getUserActivePermissions } from '../src/modules/user.js';
 import {initEngine} from "../src/setenv";
 import {generateUniqueName} from "../src/setenv.js";
@@ -207,4 +207,109 @@ describe('User Permission Logic', () => {
             await coll.drop();
         });
     });
+
+    describe('hasPermission() with environment context', () => {
+        let user, coll;
+        let permRead, permWrite;
+        let envProdId, envStagingId;
+
+        beforeAll(async () => {
+            // --- Setup ---
+            coll = await setupTestContext();
+            user = currentTestUser; // Récupère l'utilisateur du contexte
+
+            // 1. Créer les permissions
+            const perms = await coll.insertMany([
+                { _model: 'permission', name: 'env:read', _user: user.username },
+                { _model: 'permission', name: 'env:write', _user: user.username }
+            ]);
+            permRead = perms.insertedIds[0];
+            permWrite = perms.insertedIds[1];
+
+            // 2. Créer les environnements
+            const envs = await coll.insertMany([
+                { _model: 'env', name: 'prod', _user: user.username },
+                { _model: 'env', name: 'staging', _user: user.username }
+            ]);
+            envProdId = envs.insertedIds[0].toString();
+            envStagingId = envs.insertedIds[1].toString();
+
+            // 3. Créer un rôle de base et l'assigner à l'utilisateur
+            const role = await coll.insertOne({
+                _model: 'role',
+                name: 'EnvTester',
+                permissions: [permRead.toString()],
+                _user: user.username
+            });
+            await coll.updateOne(
+                { _id: user._id },
+                { $set: { roles: [role.insertedId.toString()] } }
+            );
+            // Mettre à jour l'objet utilisateur en mémoire
+            user.roles = [role.insertedId.toString()];
+            user.permissions = ['env:read'];
+        });
+
+        afterAll(async () => {
+            await coll.drop();
+        });
+
+        afterEach(async () => {
+            // Nettoyer les exceptions de permission après chaque test
+            await coll.deleteMany({ _model: 'userPermission', user: user._id });
+        });
+
+        it('should grant permission if exception is global (no env)', async () => {
+            await coll.insertOne({
+                _model: 'userPermission', user: user._id, permission: permWrite, isGranted: true
+            });
+            // L'utilisateur doit avoir la permission dans n'importe quel environnement
+            expect(await hasPermission(['env:write'], user, envProdId)).toBe(true);
+            expect(await hasPermission(['env:write'], user, envStagingId)).toBe(true);
+            expect(await hasPermission(['env:write'], user, null)).toBe(true); // Environnement par défaut
+        });
+
+        it('should grant permission only in the specified environment', async () => {
+            await coll.insertOne({
+                _model: 'userPermission', user: user._id, permission: permWrite, isGranted: true, env: envProdId
+            });
+            // L'utilisateur ne doit avoir la permission qu'en 'prod'
+            expect(await hasPermission(['env:write'], user, envProdId)).toBe(true);
+            expect(await hasPermission(['env:write'], user, envStagingId)).toBe(false);
+            expect(await hasPermission(['env:write'], user, null)).toBe(false);
+        });
+
+        it('should revoke a base permission globally if exception has no env', async () => {
+            await coll.insertOne({
+                _model: 'userPermission', user: user._id, permission: permRead, isGranted: false
+            });
+            // La permission de lecture (du rôle) doit être révoquée partout
+            expect(await hasPermission(['env:read'], user, envProdId)).toBe(false);
+            expect(await hasPermission(['env:read'], user, envStagingId)).toBe(false);
+            expect(await hasPermission(['env:read'], user, null)).toBe(false);
+        });
+
+        it('should revoke a base permission only in the specified environment', async () => {
+            await coll.insertOne({
+                _model: 'userPermission', user: user._id, permission: permRead, isGranted: false, env: envStagingId
+            });
+            // La permission de lecture ne doit être révoquée qu'en 'staging'
+            expect(await hasPermission(['env:read'], user, envProdId)).toBe(true);
+            expect(await hasPermission(['env:read'], user, envStagingId)).toBe(false);
+            expect(await hasPermission(['env:read'], user, null)).toBe(true);
+        });
+
+        it('should prioritize specific env revocation over a global grant', async () => {
+            await coll.insertMany([
+                // On accorde 'env:write' partout
+                { _model: 'userPermission', user: user._id, permission: permWrite, isGranted: true },
+                // Mais on le révoque spécifiquement pour 'staging'
+                { _model: 'userPermission', user: user._id, permission: permWrite, isGranted: false, env: envStagingId }
+            ]);
+
+            expect(await hasPermission(['env:write'], user, envProdId)).toBe(true);
+            expect(await hasPermission(['env:write'], user, envStagingId)).toBe(false);
+            expect(await hasPermission(['env:write'], user, null)).toBe(true);
+        });
+    });
 });