data-primals-engine 1.6.2 → 1.6.5

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,147 @@ 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/providers.js";
-import {parseSafeJSON, safeAssignObject} from "../core.js";
 import {Config} from "../config.js";
+import {safeAssignObject} from "../core.js";
+
+/**
+ * Récupère une valeur imbriquée dans un objet (ex: 'user.address.city').
+ */
+const getNestedValue = (obj, path) => {
+    if (!path || !obj) return undefined;
+    return path.split('.').reduce((acc, part) => acc && acc[part] !== undefined ? acc[part] : undefined, obj);
+};
+
+
+/**
+ * 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;
+}
+
 
 let logger = null;
 export async function onInit(defaultEngine) {
@@ -29,7 +164,6 @@ export async function onInit(defaultEngine) {
     await scheduleWorkflowTriggers();
 }
 
-
 /**
  * Déclenche un workflow par son nom et lui passe des données de contexte.
  * C'est la fonction clé à exposer aux endpoints pour lancer des processus métier.
@@ -969,42 +1103,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 +1218,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 +1372,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 +1383,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 +1393,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 +1410,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 +1435,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 +1478,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 +1524,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 +1541,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 +1552,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 +1583,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 +1593,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 +1617,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.