data-primals-engine 1.6.2-rc1 → 1.6.3

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;

package/src/modules/workflow.js

@@ -1,13 +1,12 @@
 import {getCollection, getCollectionForUser, isObjectId} from "./mongodb.js";
 import schedule from "node-schedule";
 import {ObjectId} from "mongodb";
-import crypto from "node:crypto";
 
 import ivm from 'isolated-vm';
 
 import {Logger} from "../gameObject.js";
 import {deleteData, getModel, insertData, patchData, searchData} from "./data/index.js";
-import { maxExecutionsByStep, maxWorkflowSteps, port} from "../constants.js";
+import { maxExecutionsByStep, maxWorkflowSteps } from "../constants.js";
 import {ChatPromptTemplate} from "@langchain/core/prompts";
 import i18n from "../../src/i18n.js";
 import {sendEmail} from "../email.js";
@@ -16,11 +15,10 @@ import * as workflowModule from './workflow.js';
 import {isConditionMet} from "../filter.js";
 import { services } from '../services/index.js';
 import {getEnv, getSmtpConfig} from "./user.js";
-import {getHost} from "../constants.js";
-import {providers} from "./assistant/constants.js";
-import {getAIProvider} from "./assistant/assistant.js";
-import {parseSafeJSON, safeAssignObject} from "../core.js";
+import { providers } from "./assistant/constants.js";
+import { getAIProvider } from "./assistant/providers.js";
 import {Config} from "../config.js";
+import {substituteVariables} from "../filter.js";
 
 let logger = null;
 export async function onInit(defaultEngine) {
@@ -29,6 +27,7 @@ export async function onInit(defaultEngine) {
     await scheduleWorkflowTriggers();
 }
 
+export { substituteVariables } from "../filter.js";
 
 /**
  * Déclenche un workflow par son nom et lui passe des données de contexte.
@@ -969,42 +968,6 @@ export async function executeStepAction(actionDef, contextData, user, dbCollecti
         return { success: false, message: error.message || 'Action execution failed' };
     }
 }
-/**
- * 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;
-}
 
 /**
  * Résout un chemin de variable complexe (ex: "triggerData.order.customer.contact.email")
@@ -1120,133 +1083,6 @@ async function resolvePathValue(pathString, initialContext, user) {
     return finalValue;
 }
 
-/**
- * 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;
-}
-
 /**
  * Triggers the instantiation of a workflowRun if conditions are met.
  * Checks the event type and trigger's data filter.
@@ -1401,6 +1237,7 @@ export async function processWorkflowRun(workflowRunId, user) {
     let currentRunState;
     let contextData = {};
     let stepExecutionsCount = {};
+    let history = [];
 
     try {
         currentRunState = await dbCollection.findOne({ _id: runId, _model: 'workflowRun' });
@@ -1411,6 +1248,7 @@ export async function processWorkflowRun(workflowRunId, user) {
         }
 
         stepExecutionsCount = currentRunState.stepExecutionsCount || {};
+        history = currentRunState.history || [];
         if (['completed', 'failed', 'cancelled'].includes(currentRunState.status)) {
             logger.info(`[processWorkflowRun] WorkflowRun ID: ${runId} is already in a terminal state (${currentRunState.status}). Skipping.`);
             return;
@@ -1420,7 +1258,7 @@ export async function processWorkflowRun(workflowRunId, user) {
             logger.error(error);
             await dbCollection.updateOne(
                 { _id: runId },
-                { $set: { status: 'failed', error, completedAt: new Date(), stepExecutionsCount } }
+                { $set: { status: 'failed', error, completedAt: new Date(), stepExecutionsCount, history } }
             );
         };
 
@@ -1437,7 +1275,7 @@ export async function processWorkflowRun(workflowRunId, user) {
             const errorMessage = workflowDefinition.startStep ? 'No valid starting step defined in workflow or run state.' : null;
             await dbCollection.updateOne(
                 { _id: runId },
-                { $set: { status: finalStatus, error: errorMessage, completedAt: new Date(), currentStep: null, stepExecutionsCount } }
+                { $set: { status: finalStatus, error: errorMessage, completedAt: new Date(), currentStep: null, stepExecutionsCount, history } }
             );
             return;
         }
@@ -1462,10 +1300,13 @@ export async function processWorkflowRun(workflowRunId, user) {
                 return await logError(`Step definition ID: ${currentStepId} not found.`);
             }
 
-            await dbCollection.updateOne(
-                { _id: runId },
-                { $set: { status: 'running', currentStep: currentStepId, contextData, stepExecutionsCount } }
-            );
+            const stepHistoryEntry = {
+                stepId: currentStepId.toString(),
+                stepName: currentStepDef.name,
+                executedAt: new Date(),
+                status: 'pending',
+                actions: []
+            };
 
             let stepSucceeded = true;
             let logInfo = null;
@@ -1502,6 +1343,14 @@ export async function processWorkflowRun(workflowRunId, user) {
                         for (const actionId of currentStepDef.actions) {
                             if (!isObjectId(actionId)) continue;
                             const actionDef = await dbCollection.findOne({ _id: new ObjectId(actionId), _model: 'workflowAction' });
+                            const actionHistoryEntry = {
+                                actionId: actionId.toString(),
+                                actionName: actionDef.name,
+                                actionType: actionDef.type,
+                                executedAt: new Date(),
+                                status: 'pending'
+                            };
+
                             if (!actionDef) return await logError(`Action definition ${actionId} not found.`);
                             const actionResult = await workflowModule.executeStepAction(actionDef, contextData, user, dbCollection);
 
@@ -1540,9 +1389,15 @@ export async function processWorkflowRun(workflowRunId, user) {
                             if (!actionResult.success) {
                                 stepSucceeded = false;
                                 logInfo = actionResult.message || `Action ${actionDef.name || actionId} failed.`;
+                                actionHistoryEntry.status = 'failed';
+                                actionHistoryEntry.result = logInfo;
+                                stepHistoryEntry.actions.push(actionHistoryEntry);
                                 break;
                             }else{
                                 logInfo = `Action ${actionDef.name || actionId} : ${actionResult.message}`;
+                                actionHistoryEntry.status = 'success';
+                                actionHistoryEntry.result = actionResult.message;
+                                stepHistoryEntry.actions.push(actionHistoryEntry);
                             }
                             if (actionResult.updatedContext) {
                                 contextData = { ...contextData, ...actionResult.updatedContext };
@@ -1551,6 +1406,10 @@ export async function processWorkflowRun(workflowRunId, user) {
                             logger.info(`[processWorkflowRun] Run ID: ${runId}, Step ID: ${currentStepId}, Action ID: ${actionId}: Executed successfully.`);
                         }
                     }
+                    if (stepSucceeded) {
+                        stepHistoryEntry.status = 'success';
+                        stepHistoryEntry.result = 'Step actions completed successfully.';
+                    }
                 } else {
                     logger.info(`[processWorkflowRun] Run ID: ${runId}, Step ID: ${currentStepId}: Conditions not met. Skipping actions.`);
                 }
@@ -1558,6 +1417,8 @@ export async function processWorkflowRun(workflowRunId, user) {
                 logger.error(`[processWorkflowRun] Run ID: ${runId}, Step ID: ${currentStepId}: Error during condition/action execution: ${error.message}`);
                 stepSucceeded = false;
                 logInfo = error.message;
+                stepHistoryEntry.status = 'failed';
+                stepHistoryEntry.result = logInfo;
             }
 
             // --- 9. Détermination de la prochaine étape ---
@@ -1587,7 +1448,7 @@ export async function processWorkflowRun(workflowRunId, user) {
 
             // --- 10. Mise à jour de l'état de l'exécution ---
             currentStepId = nextStepId;
-            const updatePayload = { contextData };
+            const updatePayload = { contextData, stepExecutionsCount }; // <-- CORRECTION: Always include stepExecutionsCount
 
             if (finalStatusForRun) {
                 updatePayload.status = finalStatusForRun;
@@ -1597,7 +1458,21 @@ export async function processWorkflowRun(workflowRunId, user) {
             } else {
                 updatePayload.currentStep = currentStepId;
             }
-            await dbCollection.updateOne({ _id: runId }, { $set: updatePayload });
+
+            // Update the last history entry with the final status and actions
+            // We use a pipeline to reliably update the last element of the history array.
+            // --- FIX ---
+            // The previous logic using $slice failed when the history array had only one element.
+            // This new logic uses a direct update on the last element of the array, which is more robust.
+            await dbCollection.updateOne(
+                { _id: runId }, {
+                    $set: updatePayload,
+                    $push: {
+                        history: stepHistoryEntry
+                    }
+                }
+            );
+
 
             if(finalStatusForRun) {
                 logger.info(`[processWorkflowRun] Finished processing for workflowRun ID: ${runId}. Final Status: ${finalStatusForRun}`);
@@ -1607,7 +1482,7 @@ export async function processWorkflowRun(workflowRunId, user) {
         logger.error(`[processWorkflowRun] Critical error during processing of workflowRun ID: ${runId}. Error: ${error.message}`, error.stack);
         await dbCollection.updateOne(
             { _id: runId, status: { $nin: ['completed', 'failed', 'cancelled'] } },
-            { $set: { status: 'failed', log: `Critical error: ${error.message}`, completedAt: new Date(), stepExecutionsCount } }
+            { $set: { status: 'failed', log: `Critical error: ${error.message}`, completedAt: new Date(), stepExecutionsCount, history } }
         );
     }
 }

package/src/providers.js

@@ -104,7 +104,7 @@ export class UserProvider {
     }
 
     async hasFeature(user, feature) {
-        return this.plans[user?.userPlan]?.features.some(f => f === feature);
+        return this.plans[user?.userPlan ?? 'free']?.features.some(f => f === feature);
     }
 
     // Ajoutez ici d'autres méthodes nécessaires : findUserById, createUser, etc.