data-primals-engine 1.6.2 → 1.6.3

package/src/defaultModels.js

@@ -14,6 +14,14 @@ export const defaultModels = {
             {
                 "name": "description",
                 "type": "richtext"
+            },
+            {
+                "name": "filter",
+                "type": "code",
+                "language": "json",
+                "conditionBuilder": true,
+                "required": false,
+                "hint": "Filtre JSON qui restreint la portée de cette permission. Le modèle cible est déduit du nom de la permission (ex: 'product.edit')."
             }
         ]
     },
@@ -1111,6 +1119,12 @@ export const defaultModels = {
                 hint: "The current status of the workflow execution."
             },
             { name: 'stepExecutionsCount', type: 'object' },
+            {
+                name: 'history',
+                type: 'array',
+                itemsType: 'object',
+                hint: "Stores the detailed execution history of each step and action."
+            },
             { name: 'currentStep', type: 'relation', relation: 'workflowStep', hint: "The step currently being executed or waited on." },
             { name: 'owner', type: 'relation', relation: 'user', required: false },
             { name: 'startedAt', type: 'datetime', required: true, hint: "Timestamp when the workflow run began." },

package/src/filter.js

@@ -1,3 +1,7 @@
+import {getCollectionForUser, isObjectId} from "./modules/mongodb.js";
+import {getModel} from "./modules/data/index.js";
+import {ObjectId} from "mongodb";
+import {safeAssignObject} from "./core.js";
 
 let safeRegex = null; // Par défaut, aucune fonction de validation n'est définie.
 
@@ -9,6 +13,42 @@ export function setSafeRegex(validator) {
     safeRegex = validator;
 }
 
+/**
+ * Récupère une valeur imbriquée dans un objet en utilisant une chaîne de chemin.
+ * Gère les tableaux et les objets. Retourne undefined si le chemin n'est pas trouvé.
+ * Exemple: getNestedValue({ a: { b: [ { c: 1 } ] } }, 'a.b.0.c') -> 1
+ *
+ * @param {object} obj L'objet source.
+ * @param {string} path La chaîne de chemin (ex: 'user.address.city').
+ * @returns {*} La valeur trouvée ou undefined.
+ */
+function getNestedValue(obj, path) {
+    // Vérifie si l'objet ou le chemin est invalide
+    if (!obj || typeof path !== 'string') {
+        return undefined;
+    }
+    // Sépare le chemin en clés individuelles (ex: 'a.b.0.c' -> ['a', 'b', '0', 'c'])
+    const keys = path.split('.');
+    let current = obj; // Commence à la racine de l'objet
+
+    // Parcourt chaque clé dans le chemin
+    for (const key of keys) {
+        // Si à un moment donné on atteint null ou undefined, le chemin est invalide
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        // Récupère la valeur pour la clé actuelle
+        const value = current[key];
+        // Si la valeur est undefined, le chemin est invalide
+        if (value === undefined) {
+            return undefined;
+        }
+        // Passe au niveau suivant de l'objet/tableau
+        current = value;
+    }
+    // Retourne la valeur finale trouvée
+    return current;
+}
 /**
  * Evaluates a single condition against form data.
  * @param {object} currentModelDef - The definition of the current model.
@@ -272,4 +312,133 @@ export const isConditionMet = (model, cond, formData, allModels, user,checkRegex
     }
 
     return evaluateSingleCondition(model, condition, formData, allModels, user, checkRegex);
-};
+};
+
+
+
+/**
+ * Remplace les placeholders dans un template (string, object, array) par des valeurs du contextData.
+ * Version améliorée avec support des chemins complexes via resolvePathValue.
+ */
+export async function substituteVariables(template, contextData, user) {
+    // 1. Retourner les types non substituables tels quels
+    if (template === null || (typeof template !== 'string' && typeof template !== 'object')) {
+        return template;
+    }
+
+    // 2. Gérer les tableaux de manière récursive
+    if (Array.isArray(template)) {
+        return Promise.all(template.map(item => substituteVariables(item, contextData, user)));
+    }
+
+    // 3. Gérer les objets de manière récursive
+    if (typeof template === 'object') {
+        const newObj = {};
+        for (const key in template) {
+            if (Object.prototype.hasOwnProperty.call(template, key)) {
+                const val = await substituteVariables(template[key], contextData, user);
+                safeAssignObject(newObj, key, val);
+            }
+        }
+        return newObj;
+    }
+
+    // --- À partir d'ici, nous savons que `template` est une chaîne de caractères ---
+
+    // 4. Construire le contexte complet pour la substitution
+    const dbCollection = await getCollectionForUser(user);
+    const userEnvVars = await dbCollection.find({ _model: 'env', _user: user.username }).toArray();
+    const userEnv = userEnvVars.reduce((acc, v) => ({ ...acc, [v.name]: v.value }), {});
+
+    // `contextToSearch` contient toutes les données disponibles à sa racine
+    const contextToSearch = { ...contextData, env: userEnv };
+
+    // 5. Logique de résolution de valeur améliorée avec resolvePathValue
+    const findValue = async (key) => {
+        let path = key.trim();
+        if (path.startsWith('context.')) {
+            path = path.substring('context.'.length);
+        }
+        if (path.endsWith('._id')) {
+            const basePath = path.slice(0, -4);
+            const value = await findValue(basePath);
+            return value?._id?.toString(); // Convertit l'ObjectId en string
+        }
+
+        // Gérer les valeurs dynamiques spéciales
+        if (path === 'now') {
+            return new Date().toISOString();
+        } else if (path === 'randomUUID') {
+            return crypto.randomUUID();
+        } else if( path === "baseUrl" ){
+            return process.env.NODE_ENV === 'production' ? 'https://'+getHost()+'/' : 'http://localhost:/'+port;
+        }
+
+        // Détecter si le chemin est complexe (contient plus d'un point)
+        if (path.split('.').length > 1) {
+            try {
+                // Essayer de résoudre le chemin avec resolvePathValue
+                const [root, ...rest] = path.split('.');
+                // On vérifie si la racine du chemin (ex: 'triggerData') existe dans notre contexte
+                if (contextToSearch[root]) {
+                    const resolvedValue = await resolvePathValue(
+                        rest.join('.'),
+                        contextToSearch[root], // On passe le bon objet de départ (ex: l'objet triggerData)
+                        user
+                    );
+                    if (resolvedValue !== undefined) {
+                        return resolvedValue;
+                    }
+                }
+            } catch (error) {
+                console.warn(`Erreur lors de la résolution du chemin "${path}":`, error.message);
+                // On continue avec la méthode normale si la résolution échoue
+            }
+        }
+
+        // Fallback: chercher le chemin dans l'objet de contexte normal
+        return getNestedValue(contextToSearch, path);
+    };
+
+    // CAS A : La chaîne est un unique placeholder (ex: "{context.triggerData.product.price}")
+    const singlePlaceholderMatch = template.match(/^\{([^}]+)\}$/);
+    if (singlePlaceholderMatch) {
+        const key = singlePlaceholderMatch[1];
+        const value = await findValue(key);
+
+        if (value === undefined) {
+            return template; // Placeholder not found, return as is.
+        }
+
+        // If the resolved value is a string, it might contain more placeholders.
+        // We recursively call substituteVariables on it, but only if it's different
+        // from the original template to prevent infinite loops.
+        if (typeof value === 'string' && value !== template) {
+            return substituteVariables(value, contextData, user);
+        }
+
+        // For non-string values or if value is same as template, return the value.
+        return value;
+    }
+
+    // CAS B : La chaîne contient plusieurs placeholders ou mix texte/variables
+    const placeholderRegex = /\{([^}]+)\}/g;
+    const placeholders = [...template.matchAll(placeholderRegex)];
+
+    // Si aucun placeholder trouvé, retourner la chaîne telle quelle
+    if (placeholders.length === 0) {
+        return template;
+    }
+
+    // Remplacer chaque placeholder de manière asynchrone
+    let result = template;
+    for (const [match, key] of placeholders) {
+        const value = await findValue(key);
+        const replacement = value !== undefined
+            ? (value === null ? 'null' : typeof value === 'object' ? JSON.stringify(value) : String(value))
+            : match;
+        result = result.replace(match, replacement);
+    }
+
+    return result;
+}

package/src/modules/data/data.history.js

@@ -391,7 +391,11 @@ export function onInit(defaultEngine) {
                 }
 
                 // If this is the first history record for this document, add a snapshot of the 'before' state.
-                if (!lastVersionDoc) {
+                // --- FIX ---
+                // The check should be based on the calculated version number, not on the existence of lastVersionDoc,
+                // which could be affected by race conditions in a busy environment. If we are creating version 1,
+                // it means no prior history exists for this document, so we must add the snapshot.
+                if (newVersion === 1) {
                     historyEntry.snapshot = beforeDoc;
                     logger.debug(`History v${newVersion} (update with initial snapshot) created for ${modelName} document ${afterDoc._id}`);
                 } else {

package/src/modules/data/data.operations.js

@@ -1679,9 +1679,15 @@ export const deleteData = async (modelName, filter, user = {}, triggerWorkflow,
             logger.info(`[deleteData] No documents to delete for user ${user?.username} after permission checks or matching criteria.`);
         }
 
-        const res = {success: true, deletedCount}
-        const plugin = await Event.Trigger("OnDataDeleted", "event", "system", engine, {model: modelName, filter});
-        await Event.Trigger("OnDataDeleted", "event", "user", {model: modelName, filter});
+        const res = { success: true, deletedCount };
+
+        // --- CORRECTION ---
+        // The event payload must match what the history listener expects: { modelName, user, before }.
+        // 'documentsToDelete' contains the full documents before they were deleted.
+        const eventPayload = { modelName: modelNameToInvalidate, user, before: documentsToDelete };
+        const plugin = await Event.Trigger("OnDataDeleted", "event", "system", engine, eventPayload);
+        await Event.Trigger("OnDataDeleted", "event", "user", eventPayload);
+
         return plugin || res;
 
     } catch (error) {

package/src/modules/user.js

@@ -15,6 +15,7 @@ import rateLimit from "express-rate-limit";
 import ivm from "isolated-vm";
 import {emailDefaultConfig} from "../constants.js";
 import {safeAssignObject} from "../core.js";
+import {substituteVariables} from "../filter.js";
 import {Config} from "../config.js";
 
 export const userInitiator = async (req, res, next) => {
@@ -105,35 +106,38 @@ export async function onInit(defaultEngine) {
  * 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) {
     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" } },
+            { $match: { _id: { $in: roleIds }, _model: "role", _user: user.username } },
             { $unwind: "$permissions" },
-            { $addFields: { "permissionId": { "$toObjectId": "$permissions" } } },
             {
                 $lookup: {
                     from: datasCollection.collectionName, // Utiliser la même collection
-                    localField: "permissionId",
-                    foreignField: "_id",
+                    let: { permissionIdStr: "$permissions" }, // La permission est un string
+                    pipeline: [
+                        { $match: {
+                            $expr: { $eq: [ { $toString: "$_id" }, "$$permissionIdStr" ] }
+                        }}
+                    ],
                     as: "permissionDoc"
                 }
             },
             { $unwind: "$permissionDoc" },
-            { $group: { _id: "$permissionDoc.name" } }
+            { $project: { name: "$permissionDoc.name", filter: "$permissionDoc.filter" } }
         ]).toArray();
 
-        rolePermissions.forEach(p => p._id && activePermissions.add(p._id));
+        rolePermissions.forEach(p => p.name && activePermissions.set(p.name, p.filter ?? null));
     }
 
     // --- ÉTAPE 2: Appliquer les exceptions de permission ---
@@ -141,7 +145,7 @@ export async function getUserActivePermissions(user, env = null) {
         {
             $match: { // Filtre de base pour les exceptions de l'utilisateur
                 _model: "userPermission",
-                user: user._id,
+                user: user._id.toString(),
                 $and: [ // Filtre sur l'environnement et l'expiration
                     {
                         $or: [ // La permission est soit globale, soit spécifique à l'environnement demandé
@@ -160,20 +164,22 @@ export async function getUserActivePermissions(user, env = null) {
                 pipeline: [
                     {
                         $match: {
-                            $expr: {
-                                $eq: [
-                                    "$_id",
-                                    { $toObjectId: "$$permissionId" } // Conversion ici
-                                ]
-                            }
+                            $expr: { $eq: [ { $toString: "$_id" }, "$$permissionId" ] }
                         }
                     },
-                    { $project: { name: 1 } }
+                    { $project: { name: 1, filter: 1 } }
                 ],
                 as: 'permissionDoc'
             }
         },
-        { $unwind: '$permissionDoc' }
+        { $unwind: '$permissionDoc' },
+        {
+            $project: { // On sélectionne les champs dont on a besoin
+                isGranted: 1,
+                filter: 1, // On ajoute le filtre de l'exception
+                permissionDoc: 1
+            }
+        }
     ]).toArray();
 
     // Appliquer les exceptions
@@ -182,7 +188,11 @@ export async function getUserActivePermissions(user, env = null) {
         if (!permissionName) continue;
 
         if (exception.isGranted) {
-            activePermissions.add(permissionName);
+            // Priorité 1: Le filtre défini sur l'exception elle-même.
+            // Priorité 2: Le filtre défini sur la permission de base.
+            // Priorité 3: null s'il n'y a aucun filtre.
+            const finalFilter = exception.filter ?? exception.permissionDoc.filter ?? null;
+            activePermissions.set(permissionName, finalFilter);
         } else {
             activePermissions.delete(permissionName);
         }
@@ -195,15 +205,19 @@ export async function getUserActivePermissions(user, env = null) {
  * 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 {
@@ -216,9 +230,27 @@ export async function hasPermission(permissionNames, user, env = null) {
         // 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;