data-primals-engine 1.6.2 → 1.6.3

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/providers.js";
-import {parseSafeJSON, safeAssignObject} from "../core.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.

package/test/data.history.integration.test.js

@@ -1,10 +1,10 @@
 // __tests__/data.history.integration.test.js
 import { ObjectId } from 'mongodb';
 import { expect, describe, it, beforeAll, afterAll, beforeEach } from 'vitest';
-import { handleGetHistoryRequest } from '../src/modules/data/data.history.js';
+import { handleGetHistoryRequest, handleGetRevisionRequest, handleRevertToRevisionRequest } from '../src/modules/data/data.history.js';
 import { Config } from '../src/config.js';
 import { sleep } from '../src/core.js';
-import { insertData, editData, deleteModels } from '../src/index.js';
+import { insertData, editData, deleteData } from '../src/index.js';
 import { getCollection, getCollectionForUser } from '../src/modules/mongodb.js';
 import { generateUniqueName, initEngine } from "../src/setenv.js";
 import {purgeData} from "../src/modules/data/data.history.js";
@@ -16,6 +16,20 @@ let historyCollection;
 let datasCollection;
 let modelsCollection;
 
+// Mock Express req/res objects for testing API handlers
+const mockReq = (params = {}, query = {}, body = {}, user = testUser) => ({
+    params,
+    query,
+    body,
+    me: user
+});
+const mockRes = () => {
+    const res = {};
+    res.status = (code) => { res.statusCode = code; return res; };
+    res.json = (data) => { res.body = data; return res; };
+    return res;
+};
+
 describe('Data History Module Integration Tests', () => {
 
     beforeAll(async () => {
@@ -192,6 +206,126 @@ describe('Data History Module Integration Tests', () => {
         expect(historyCount).toBe(1);
     });
 
+    it('should create a snapshot history record on document deletion', async () => {
+        // 1. Setup model
+        const modelName = generateUniqueName('productHistoryDelete');
+        const productModelDef = {
+            name: modelName,
+            description:'',
+            _user: testUser.username,
+            history: { enabled: true },
+            fields: [{ name: 'name', type: 'string' }]
+        };
+        await modelsCollection.insertOne(productModelDef);
+
+        // 2. Insert a document
+        const insertResult = await insertData(modelName, { name: 'Document to be deleted' }, {}, testUser);
+        const docId = new ObjectId(insertResult.data._id);
+
+        // 3. Delete the document
+        await deleteData(modelName, [docId.toString()], testUser);
+
+        // 4. Verify the new history record (v2)
+        const historyRecord = await historyCollection.findOne({ documentId: docId, version: 2 });
+
+        expect(historyRecord).not.toBeNull();
+        expect(historyRecord.operation).toBe('delete');
+        expect(historyRecord.snapshot).not.toBeNull();
+        expect(historyRecord.snapshot.name).toBe('Document to be deleted');
+        expect(historyRecord.changes).toBeUndefined();
+    });
+
+    it('should correctly reconstruct a document at a specific version', async () => {
+        // 1. Setup model
+        const modelName = generateUniqueName('productHistoryReconstruct');
+        const productModelDef = {
+            name: modelName,
+            _user: testUser.username,
+            description:'',
+            history: { enabled: true },
+            fields: [
+                { name: 'name', type: 'string' },
+                { name: 'status', type: 'string' },
+                { name: 'count', type: 'number' }
+            ]
+        };
+        await modelsCollection.insertOne(productModelDef);
+
+        // 2. Create and update document to generate history
+        const insertResult = await insertData(modelName, { name: 'Reconstruct', status: 'initial', count: 0 }, {}, testUser); // v1
+        const docId = new ObjectId(insertResult.data._id);
+
+        await editData(modelName, { _id: docId }, { status: 'updated' }, {}, testUser); // v2
+        await editData(modelName, { _id: docId }, { count: 10 }, {}, testUser); // v3
+
+        // 3. Test reconstruction at each version via the API handler
+        // Version 1 (creation)
+        let req = mockReq({ modelName, recordId: docId.toString(), version: '1' });
+        let res = mockRes();
+        await handleGetRevisionRequest(req, res);
+        expect(res.body.success).toBe(true);
+        expect(res.body.data.name).toBe('Reconstruct');
+        expect(res.body.data.status).toBe('initial');
+        expect(res.body.data.count).toBe(0);
+
+        // Version 2 (status updated)
+        req = mockReq({ modelName, recordId: docId.toString(), version: '2' });
+        res = mockRes();
+        await handleGetRevisionRequest(req, res);
+        expect(res.body.success).toBe(true);
+        expect(res.body.data.status).toBe('updated');
+        expect(res.body.data.count).toBe(0); // count is still 0
+
+        // Version 3 (count updated)
+        req = mockReq({ modelName, recordId: docId.toString(), version: '3' });
+        res = mockRes();
+        await handleGetRevisionRequest(req, res);
+        expect(res.body.success).toBe(true);
+        expect(res.body.data.status).toBe('updated');
+        expect(res.body.data.count).toBe(10);
+    });
+
+    it('should revert a document to a previous version and create a new history entry', async () => {
+        // 1. Setup model
+        const modelName = generateUniqueName('productHistoryRevert');
+        const productModelDef = {
+            name: modelName,
+            _user: testUser.username,
+            description:'',
+            history: { enabled: true },
+            fields: [{ name: 'name', type: 'string' }, { name: 'status', type: 'string' }]
+        };
+        await modelsCollection.insertOne(productModelDef);
+
+        // 2. Create and update document
+        const insertResult = await insertData(modelName, { name: 'Revert Test', status: 'v1' }, {}, testUser); // v1
+        const docId = new ObjectId(insertResult.data._id);
+        await editData(modelName, { _id: docId }, { status: 'v2' }, {}, testUser); // v2
+
+        // 3. Revert the document to version 1
+        const req = mockReq({ modelName, recordId: docId.toString(), version: '1' });
+        const res = mockRes();
+        await handleRevertToRevisionRequest(req, res);
+
+        expect(res.body.success).toBe(true);
+        expect(res.body.message).toBe("Document successfully reverted.");
+
+        // 4. Verify the current state of the document
+        const revertedDoc = await datasCollection.findOne({ _id: docId });
+        expect(revertedDoc.status).toBe('v1');
+
+        // 5. Verify that a new history entry (v3) was created for the revert action
+        const historyRecords = await historyCollection.find({ documentId: docId }).sort({ version: 1 }).toArray();
+        expect(historyRecords).toHaveLength(3);
+
+        const revertHistoryEntry = historyRecords[2]; // v3
+        expect(revertHistoryEntry.version).toBe(3);
+        expect(revertHistoryEntry.operation).toBe('update'); // A revert is an update
+        expect(revertHistoryEntry.changes).not.toBeNull();
+        expect(revertHistoryEntry.changes.status.from).toBe('v2');
+        expect(revertHistoryEntry.changes.status.to).toBe('v1');
+    });
+
     it('should filter history records by date range', async () => {
         // 1. Setup model
         const modelName = generateUniqueName('productHistoryDateFilter');
@@ -227,21 +361,11 @@ describe('Data History Module Integration Tests', () => {
         });
 
         // Mock Express req/res objects
-        const mockReq = (query) => ({
-            params: { modelName, recordId: docId.toString() },
-            query,
-            me: testUser
-        });
-        const mockRes = () => {
-            const res = {};
-            res.status = (code) => { res.statusCode = code; return res; };
-            res.json = (data) => { res.body = data; return res; };
-            return res;
-        };
+        // Using the global mockReq and mockRes helpers now
 
         // 4. Test cases
         // Case A: Filter for February
-        let req = mockReq({ startDate: '2023-02-01', endDate: '2023-02-28' });
+        let req = mockReq({ modelName, recordId: docId.toString() }, { startDate: '2023-02-01', endDate: '2023-02-28' });
         let res = mockRes();
         await handleGetHistoryRequest(req, res);
         expect(res.body.success).toBe(true);
@@ -249,14 +373,14 @@ describe('Data History Module Integration Tests', () => {
         expect(res.body.data.map(d => d._v).sort()).toEqual([2, 3]);
 
         // Case B: Filter starting from Feb 15th
-        req = mockReq({ startDate: '2023-02-15' });
+        req = mockReq({ modelName, recordId: docId.toString() }, { startDate: '2023-02-15' });
         res = mockRes();
         await handleGetHistoryRequest(req, res);
         expect(res.body.success).toBe(true);
         expect(res.body.count).toBe(3); // v2, v3, v4
 
         // Case C: Filter up to Feb 15th (inclusive)
-        req = mockReq({ endDate: '2023-02-15' });
+        req = mockReq({ modelName, recordId: docId.toString() }, { endDate: '2023-02-15' });
         res = mockRes();
         await handleGetHistoryRequest(req, res);
         expect(res.body.success).toBe(true);