data-primals-engine 1.1.0 → 1.1.2

package/src/modules/workflow.js

@@ -4,17 +4,16 @@ import schedule from "node-schedule";
 import {ObjectId} from "mongodb";
 import crypto from "node:crypto";
 
+import {NodeVM, VM, VMScript} from 'vm2';
 import {Logger} from "../gameObject.js";
-import {deleteData, editData, insertData, patchData, searchData} from "./data.js";
-import {maxExecutionsByStep, maxWorkflowSteps} from "../constants.js";
-import { ChatOpenAI } from "@langchain/openai";
-import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
-import { ChatPromptTemplate } from "@langchain/core/prompts";
+import {deleteData, insertData, patchData, searchData} from "./data.js";
+import {maxExecutionsByStep, maxWorkflowSteps, timeoutVM} from "../constants.js";
+import {ChatOpenAI} from "@langchain/openai";
+import {ChatGoogleGenerativeAI} from "@langchain/google-genai";
+import {ChatPromptTemplate} from "@langchain/core/prompts";
 import i18n from "data-primals-engine/i18n";
 import {sendEmail} from "../email.js";
 
-// 1. ADD THIS IMPORT AT THE TOP OF THE FILE
-// This allows the module to call its own exported functions.
 import * as workflowModule from './workflow.js';
 
 let logger = null;
@@ -181,6 +180,144 @@ export async function scheduleWorkflowTriggers() {
 }
 
 
+/* Remplacement de la fonction executeSafeJavascript
+async function executeWithIsolatedVm(actionDef, context) {
+    const code = actionDef.script;
+    const isolate = new ivm.Isolate({ memoryLimit: 128 }); // Limite de 128MB de mémoire
+
+    try {
+        const vmContext = await isolate.createContext();
+        const jail = vmContext.global;
+
+        // On expose une fonction 'log' sécurisée à l'intérieur de la VM.
+        // C'est une référence, pas la fonction elle-même.
+        await jail.set('log', new ivm.Reference(function(...args) {
+            // On peut préfixer les logs pour savoir qu'ils viennent de la VM
+            logger.info('[VM Script Log]', ...args);
+        }));
+
+        // On injecte les données du contexte. Elles sont COPIÉES, pas référencées.
+        // C'est une caractéristique de sécurité clé.
+        await jail.set('contextData', new ivm.ExternalCopy(context).copyInto());
+        // On peut aussi exposer des fonctions spécifiques de votre application
+        // await jail.set('myApiFunction', new ivm.Reference(async (params) => { ... }));
+
+        // On compile le script
+        const script = await isolate.compileScript(code);
+
+        // On exécute le script avec un timeout
+        const result = await script.run(vmContext, { timeout: 1000 });
+
+        // Le résultat est une référence, on le copie pour l'utiliser dans notre contexte principal.
+        return result;
+
+    } catch (error) {
+        logger.error("Error executing script with isolated-vm:", error.stack);
+        // On propage une erreur propre
+        throw new Error(`Script execution failed: ${error.message}`);
+    } finally {
+        // TRÈS IMPORTANT : Toujours libérer l'isolate pour éviter les fuites de mémoire.
+        if (isolate && !isolate.isDisposed) {
+            isolate.dispose();
+        }
+    }
+}
+REQUIRES NODE >=20
+ */
+
+export async function executeSafeJavascript(actionDef, context, user) {
+    const code = actionDef.script;
+    const collectedLogs = []; // Tableau pour capturer les logs de cette exécution
+
+    // 1. Construire l'API qui sera exposée au script
+    const scriptApi = {
+        db: {
+            create: (modelName, dataObject) => insertData(modelName, dataObject, {}, user),
+            find: async (modelName, filter) => {
+                const result = await searchData({ user, query: { model: modelName, filter } });
+                return result.data;
+            },
+            findOne: async (modelName, filter) => {
+                const result = await searchData({ user, query: { model: modelName, filter, limit: 1 } });
+                return result.data?.[0] || null;
+            },
+            update: (modelName, filter, updateObject) => patchData(modelName, filter, updateObject, {}, user),
+            delete: (modelName, filter) => deleteData(modelName, null, filter, user)
+        },
+        logger: {
+            // Chaque fonction de log utilise maintenant logger.trace() pour générer le message final
+            info: (...args) => {
+                // On génère le message final formaté une seule fois avec trace()
+                const finalMessage = logger.trace('info', '[VM Script]', ...args);
+                // On l'affiche en couleur dans la console du serveur
+                // On stocke ce même message final dans les logs collectés
+                collectedLogs.push({
+                    level: 'info',
+                    message: finalMessage, // Le message complet est stocké
+                    timestamp: new Date().toISOString()
+                });
+            },
+            warn: (...args) => {
+                const finalMessage = logger.trace('warn', '[VM Script]', ...args);
+                collectedLogs.push({
+                    level: 'warn',
+                    message: finalMessage,
+                    timestamp: new Date().toISOString()
+                });
+            },
+            error: (...args) => {
+                const finalMessage = logger.trace('error', '[VM Script]', ...args);
+                collectedLogs.push({
+                    level: 'error',
+                    message: finalMessage,
+                    timestamp: new Date().toISOString()
+                });
+            }
+        },
+        env: {
+            get: async (variableName) => {
+                if (!variableName) return null;
+                const result = await searchData({ user, query: { model: 'env', filter: { name: variableName }, limit: 1 } });
+                return result.data?.[0]?.value || null;
+            },
+            getAll: async () => {
+                const result = await searchData({ user, query: { model: 'env' } });
+                // Retourne un objet { NOM: valeur, ... } plus pratique
+                return result.data.reduce((acc, v) => {
+                    acc[v.name] = v.value;
+                    return acc;
+                }, {});
+            }
+        },
+        ...context
+    };
+
+    const vm = new NodeVM({
+        timeout: timeoutVM,
+        sandbox: scriptApi,
+        console: 'off',
+        require: false,
+        wasm: false
+    });
+
+    try {
+        const script = new VMScript(`const script = () => {${code}}; module.exports = script();`);
+        const result= vm.run(script);
+        return { success: true, data: result, logs: collectedLogs };
+    } catch (error) {
+        const errorMessage = `Script execution failed: ${error.message}`;
+
+        // On utilise aussi trace() pour l'erreur critique
+        const finalErrorMessage = logger.trace('critical', `[VM Script] ${errorMessage}\n${error.stack}`);
+        collectedLogs.push({
+            level: 'critical',
+            message: finalErrorMessage,
+            timestamp: new Date().toISOString()
+        });
+
+        return { success: false, message: errorMessage, logs: collectedLogs };
+    }
+}
 /**
  * Handles the 'Webhook' workflow action.
  * Sends an HTTP request to a specified URL with substituted data using native fetch.
@@ -671,8 +808,9 @@ export async function executeStepAction(actionDef, contextData, user, dbCollecti
         case 'SendEmail':
             result = await handleSendEmailAction(actionDef, contextData, user);
             break;
-                
-            // ... autres cases à venir ...
+        case 'ExecuteScript':
+            result = await executeSafeJavascript(actionDef, contextData, user);
+            break;
         default:
             logger.error(`[executeStepAction] Unknown action type: ${actionDef.type}`);
             return { success: false, message: `Unknown action type: ${actionDef.type}` };
@@ -1179,7 +1317,7 @@ export async function processWorkflowRun(workflowRunId, user) {
             );
 
             let stepSucceeded = true;
-            let stepError = null;
+            let logInfo = null;
             let conditionsMet = true;
 
             try {
@@ -1201,8 +1339,10 @@ export async function processWorkflowRun(workflowRunId, user) {
                             const actionResult = await workflowModule.executeStepAction(actionDef, contextData, user, dbCollection);
                             if (!actionResult.success) {
                                 stepSucceeded = false;
-                                stepError = actionResult.message || `Action ${actionDef.name || actionId} failed.`;
+                                logInfo = actionResult.message || `Action ${actionDef.name || actionId} failed.`;
                                 break;
+                            }else{
+                                logInfo = `Action ${actionDef.name || actionId} : ${actionResult.message}`;
                             }
                             if (actionResult.updatedContext) {
                                 contextData = { ...contextData, ...actionResult.updatedContext };
@@ -1216,7 +1356,7 @@ export async function processWorkflowRun(workflowRunId, user) {
             } catch (error) {
                 logger.error(`[processWorkflowRun] Run ID: ${runId}, Step ID: ${currentStepId}: Error during condition/action execution: ${error.message}`);
                 stepSucceeded = false;
-                stepError = error.message;
+                logInfo = error.message;
             }
 
             // --- 9. Détermination de la prochaine étape ---
@@ -1233,13 +1373,13 @@ export async function processWorkflowRun(workflowRunId, user) {
                 }
             } else {
                 // CHEMIN ÉCHEC/BRANCHE : Une action a échoué OU les conditions n'ont pas été remplies.
-                const reason = stepError ? `Action failed: ${stepError}` : 'Step conditions not met.';
+                const reason = logInfo ? `Action failed: ${logInfo}` : 'Step conditions not met.';
                 logger.warn(`[processWorkflowRun] Run ID: ${runId}, Step ID: ${currentStepId}: Taking failure/branching path. Reason: ${reason}`);
                 nextStepId = currentStepDef.onFailureStep;
 
                 if (!nextStepId || !isObjectId(nextStepId)) {
                     // Fin du workflow. Le statut est 'failed' seulement si une vraie erreur s'est produite.
-                    finalStatusForRun = stepError ? 'failed' : 'completed';
+                    finalStatusForRun = logInfo ? 'failed' : 'completed';
                     nextStepId = null;
                 }
             }
@@ -1252,9 +1392,7 @@ export async function processWorkflowRun(workflowRunId, user) {
                 updatePayload.status = finalStatusForRun;
                 updatePayload.completedAt = new Date();
                 updatePayload.currentStep = null;
-                if (finalStatusForRun === 'failed' && stepError) {
-                    updatePayload.error = stepError;
-                }
+                updatePayload.log = logInfo;
             } else {
                 updatePayload.currentStep = currentStepId;
             }

package/test/data.integration.test.js

@@ -723,7 +723,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const packId = packInsertResult.insertedId;
 
             // 3. Appeler la fonction à tester avec la nouvelle signature
-            const result = await installPack(console, packId, currentTestUser, 'en');
+            const result = await installPack(packId, currentTestUser, 'en');
 
             // 4. Assertions sur le résumé de l'installation
             expect(result.success, `L'installation du pack a échoué: ${result.errors?.join('; ')}`).toBe(true);
@@ -776,7 +776,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const packInsertResult = await testPacksColInstance.insertOne(mockPackWithInvalidModel);
             const packId = packInsertResult.insertedId;
 
-            const result = await installPack(console, packId, currentTestUser, 'en');
+            const result = await installPack(packId, currentTestUser, 'en');
 
             // Le succès global est faux s'il y a des erreurs
             expect(result.success).toBe(false);