data-primals-engine 1.6.2 → 1.6.5

package/src/modules/user.js

@@ -15,7 +15,10 @@ import rateLimit from "express-rate-limit";
 import ivm from "isolated-vm";
 import {emailDefaultConfig} from "../constants.js";
 import {safeAssignObject} from "../core.js";
+import {substituteVariables} from "./workflow.js";
+import NodeCache from "node-cache";
 import {Config} from "../config.js";
+import { Event } from '../events.js';
 
 export const userInitiator = async (req, res, next) => {
 
@@ -98,127 +101,186 @@ let logger,engine;
 export async function onInit(defaultEngine) {
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
+
+    const invalidatePermissionsCache = (engine, {modelName, insertedDocs, user}) => {
+        const modelsToWatch = ['role', 'permission', 'userPermission'];
+
+        // Le payload contient le nom du modèle qui a été modifié.
+        if (modelName && modelsToWatch.includes(modelName)) {
+            logger.info(`[Permissions] Invalidating permissions cache due to change in '${modelName}'.`);
+            permissionsCache.flushAll();
+        }
+    };
+
+    // On attache notre fonction d'invalidation aux événements système.
+    Event.Listen("OnDataAdded", invalidatePermissionsCache, "event", "system");
+    Event.Listen("OnDataEdited", invalidatePermissionsCache, "event", "system");
+    Event.Listen("OnDataDeleted", invalidatePermissionsCache, "event", "system");
 }
+/**
+ * Cache pour les permissions des utilisateurs.
+ * TTL de 10 minutes, vérification toutes les 2 minutes.
+ */
+const permissionsCache = new NodeCache({ stdTTL: 600, checkperiod: 120, useClones: false });
+
 /**
  * Calcule et retourne l'ensemble des permissions actives pour un utilisateur.
  * Cette fonction interne est la pierre angulaire de la nouvelle logique de permission.
  * 1. Elle récupère toutes les permissions de base issues des rôles de l'utilisateur.
  * 2. Elle applique ensuite les "exceptions" (ajouts ou retraits de permissions) qui sont valides (non expirées).
  * @param {object} user - L'objet utilisateur pour lequel calculer les permissions.
- * @returns {Promise<Set<string>>} Un Set contenant les noms de toutes les permissions actives.
+ * @returns {Promise<Map<string, object|null>>} Une Map contenant les noms des permissions actives et leur filtre associé.
  * @private
  */
 export async function getUserActivePermissions(user, env = null) {
+    // Clé de cache unique pour l'utilisateur et l'environnement
+    const cacheKey = `${user._user || user.username}:${user._id.toString()}:${env || 'global'}`;
+    const cachedPermissions = permissionsCache.get(cacheKey);
+    if (cachedPermissions) {
+        logger.debug(`[Permissions] Cache hit for user ${user.username}`);
+        return cachedPermissions;
+    }
+    logger.debug(`[Permissions] Cache miss for user ${user.username}. Calculating permissions...`);
     const datasCollection = await getCollectionForUser(user);
     const now = new Date();
-    const activePermissions = new Set();
+    const activePermissions = new Map();
 
     // --- ÉTAPE 1: Récupérer les permissions de base des rôles ---
     if (user.roles && user.roles.length > 0) {
         const roleIds = user.roles.map(id => new ObjectId(id));
 
-        const rolePermissions = await datasCollection.aggregate([
-            { $match: { _id: { $in: roleIds }, _model: "role" } },
-            { $unwind: "$permissions" },
-            { $addFields: { "permissionId": { "$toObjectId": "$permissions" } } },
-            {
-                $lookup: {
-                    from: datasCollection.collectionName, // Utiliser la même collection
-                    localField: "permissionId",
-                    foreignField: "_id",
-                    as: "permissionDoc"
-                }
-            },
-            { $unwind: "$permissionDoc" },
-            { $group: { _id: "$permissionDoc.name" } }
-        ]).toArray();
-
-        rolePermissions.forEach(p => p._id && activePermissions.add(p._id));
+        // Étape 1: Récupérer tous les IDs de permission des rôles de l'utilisateur.
+        const roles = await datasCollection.find(
+            { _id: { $in: roleIds }, _model: "role", _user: user._user || user.username },
+            { projection: { permissions: 1, _user: 1 } }
+        ).toArray();
+
+        // Aplatir tous les tableaux de permissions en un seul et supprimer les doublons.
+        const permissionIdStrings = [...new Set(roles.flatMap(role => role.permissions || []))];
+        const permissionObjectIds = permissionIdStrings.map(id => new ObjectId(id));
+
+        // Étape 2: Récupérer tous les documents de permission correspondants en une seule requête.
+        const rolePermissions = await datasCollection.find(
+            { _id: { $in: permissionObjectIds }, _model: "permission", _user: user._user || user.username },
+            { projection: { name: 1, filter: 1 } }
+        ).toArray();
+
+        rolePermissions.forEach(p => {
+            if (p.name) {
+                // On stocke l'objet permission complet pour un accès ultérieur
+                activePermissions.set(p.name, { filter: p.filter ?? null, details: p });
+            }
+        });
     }
 
-    // --- ÉTAPE 2: Appliquer les exceptions de permission ---
-    const exceptions = await datasCollection.aggregate([
-        {
-            $match: { // Filtre de base pour les exceptions de l'utilisateur
-                _model: "userPermission",
-                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 } }] }
-                ]
-            }
-        },
-        {
-            $lookup: {
-                from: datasCollection.collectionName,
-                let: { permissionId: "$permission" },
-                pipeline: [
-                    {
-                        $match: {
-                            $expr: {
-                                $eq: [
-                                    "$_id",
-                                    { $toObjectId: "$$permissionId" } // Conversion ici
-                                ]
-                            }
-                        }
-                    },
-                    { $project: { name: 1 } }
-                ],
-                as: 'permissionDoc'
-            }
-        },
-        { $unwind: '$permissionDoc' }
-    ]).toArray();
+    // --- NOUVELLE ÉTAPE : Pré-charger les détails de toutes les permissions d'exception ---
+    // Cela garantit que nous avons les noms de permission même pour les révocations.
+    const exceptionPermissionIds = (await datasCollection.distinct("permission", {
+        _model: "userPermission",
+        user: user._id.toString(),
+        _user: user._user || user.username
+    })).map(id => new ObjectId(id));
 
-    // Appliquer les exceptions
-    for (const exception of exceptions) {
-        const permissionName = exception.permissionDoc?.name;
-        if (!permissionName) continue;
+    const exceptionPermsDetails = await datasCollection.find(
+        { _id: { $in: exceptionPermissionIds }, _model: "permission" },
+        { projection: { name: 1, filter: 1 } }
+    ).toArray();
 
-        if (exception.isGranted) {
-            activePermissions.add(permissionName);
-        } else {
-            activePermissions.delete(permissionName);
+    const allPermDetailsMap = new Map(exceptionPermsDetails.map(p => [p._id.toString(), p]));
+
+    // --- ÉTAPE 2: Appliquer les exceptions de permission ---
+    const exceptionsQuery = {
+        _model: "userPermission",
+        user: user._id.toString(),
+        _user: user._user || user.username,
+        $and: [
+            { $or: [{ expiresAt: { $exists: false } }, { expiresAt: { $gt: now } }] },
+            { $or: [{ env: { $exists: false } }, { env: env }] }
+        ]
+    };
+
+    const exceptions = await datasCollection.find(exceptionsQuery, {
+        projection: { permission: 1, isGranted: 1, filter: 1 } // Le filtre sur l'exception
+    }).toArray();
+
+    if (exceptions.length > 0) {
+        for (const exception of exceptions) {
+            // Utiliser la map pré-chargée qui contient toutes les permissions d'exception
+            const permDetails = allPermDetailsMap.get(exception.permission);
+            if (!permDetails?.name) continue;
+
+            if (exception.isGranted) {
+                // Priorité 1: Le filtre défini sur l'exception elle-même.
+                // Priorité 2: Le filtre défini sur la permission de base.
+                const finalFilter = exception.filter ?? permDetails.filter ?? null;
+                // On met à jour l'entrée existante ou on en crée une nouvelle
+                activePermissions.set(permDetails.name, { filter: finalFilter, details: permDetails });
+            } else {
+                activePermissions.delete(permDetails.name);
+            }
         }
     }
 
-    return activePermissions;
+    // Mettre le résultat en cache avant de le retourner
+    // On ne stocke que le nom et le filtre, pas l'objet 'details' complet
+    const finalPermissionsToCache = new Map();
+    for (const [name, permData] of activePermissions.entries()) {
+        finalPermissionsToCache.set(name, permData.filter);
+    }
+    permissionsCache.set(cacheKey, finalPermissionsToCache);
+    return finalPermissionsToCache;
 }
 
 /**
  * Vérifie si un utilisateur possède au moins une des permissions spécifiées.
  * Cette fonction utilise la nouvelle logique basée sur les rôles et les exceptions de permission.
  * @param {string|string[]} permissionNames - Le nom de la permission ou un tableau de noms.
- * @param {object} user - L'objet utilisateur authentifié.
- * @returns {Promise<boolean>} - True si l'utilisateur a la permission, sinon false.
+ * @param {object} user - L'objet utilisateur.
+ * @param {string|null} env - L'environnement de la permission.
+ * @param {object|null} req - L'objet requête Express optionnel.
+ * @returns {Promise<boolean|object>} - `false` si aucune permission n'est trouvée. Sinon, retourne le filtre de la première permission trouvée (ou `true` si aucun filtre n'est défini).
  */
-export async function hasPermission(permissionNames, user, env = null) {
+export async function hasPermission(permissionNames, user, env = null, req = null) {
     // Garde la compatibilité pour les utilisateurs non-locaux (ex: système)
     if (!isLocalUser(user)) {
         const userRoles = new Set(user.roles || []);
         const requiredPermissions = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
-        return requiredPermissions.some(p => userRoles.has(p));
+        const hasPerm = requiredPermissions.some(p => userRoles.has(p));
+        // Pour les non-locaux, on ne gère pas les filtres complexes, on retourne juste true/false.
+        return hasPerm ? true : false;
     }
 
     try {
+        // 1. Obtenir l'ensemble final et à jour des permissions de l'utilisateur
+        const activePermissions = await getUserActivePermissions(user, env);
+
         const requiredPermissions = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
         // Si aucune permission n'est requise, on autorise
         if (requiredPermissions.length === 0) {
             return true;
         }
 
-        // 1. Obtenir l'ensemble final et à jour des permissions de l'utilisateur
-        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)) || false;
+        // 2. Chercher la première permission correspondante
+        for (const pName of requiredPermissions) {
+            if (activePermissions.has(pName)) {
+                const filter = activePermissions.get(pName);
+                // Si un filtre existe, on substitue les variables
+                if (filter && typeof filter === 'object' && Object.keys(filter).length > 0) {
+                    // Le contexte de substitution est enrichi avec des données pertinentes
+                    const context = {
+                        user,
+                        permissionName: pName,
+                        env,
+                        now: new Date(),
+                        req: req ? { query: req.query, body: req.body, params: req.params, ip: req.ip } : null
+                    };
+                    return await substituteVariables(filter, context, user);
+                }
+                return true; // Pas de filtre ou filtre vide, on autorise sans condition supplémentaire
+            }
+        }
 
+        return false; // Aucune permission trouvée
     } catch (e) {
         logger.error("Erreur lors de la vérification des permissions :", e);
         return false;