data-primals-engine 1.7.1 → 1.7.3

package/src/modules/mongodb.js

@@ -1,73 +1,76 @@
-
-import {Logger} from "../gameObject.js";
-import {MongoDatabase} from "../engine.js";
-import {ObjectId} from "mongodb";
-import {isLocalUser} from "../data.js";
-import {Event} from "../events.js";
-import {Config} from "../config.js";
-
-export let modelsCollection, datasCollection, filesCollection, packsCollection;
-
-export {ObjectId};
-
-let engine, logger, currentDb
-
-let colls= [];
-export async function onInit(defaultEngine) {
-    engine = defaultEngine;
-    logger = engine.getComponent(Logger);
-
-    currentDb = MongoDatabase();
-    modelsCollection = getCollection("models");
-    datasCollection = getCollection(Config.Get('dataCollection', 'datas'));
-    filesCollection = getCollection("files");
-    packsCollection = getCollection("packs");
-
-    colls = await currentDb.listCollections().toArray();
-
-    await Event.Trigger("OnDatabaseLoaded", "system", "calls", engine)
-    logger.info("MongoDB collections loaded.");
-}
-
-export const getCollections= async (forceRefresh)=>{
-    if( !forceRefresh )
-        return colls;
-    colls = await currentDb.listCollections().toArray();
-}
-
-export const createCollection = async (coll)=>{
-    const found =colls.find(f => f.name === coll);
-    if( found){
-        return getCollection(coll);
-    }
-    return await currentDb.createCollection(coll);
-}
-
-export const isObjectId = (id) => {
-    return (typeof(id) === 'string' && id.match(/^[0-9a-fA-F]{24}$/));
-};
-
-
-export const getCollection = (str) => {
-    return currentDb.collection(str);
-}
-
-export const getDatabase = () => {
-    return currentDb;
-}
-
-// New function to determine the collection name for a user
-export const getUserCollectionName = async (user) => {
-    const feat = await engine.userProvider.hasFeature(user, 'indexes');
-    const dataCollectionName = Config.Get('dataCollection', 'datas');
-    return feat ? (isLocalUser(user) ? `${dataCollectionName}_${user._user}` :`${dataCollectionName}_${user.username}` ) : dataCollectionName;
-};
-
-
-// Modify existing functions to use the correct collection
-export const getCollectionForUser = async (user) => {
-    const collectionName = await getUserCollectionName(user);
-    return getCollection(collectionName);
-};
-
-
+
+import {Logger} from "../gameObject.js";
+import {MongoDatabase} from "../engine.js";
+import {ObjectId} from "mongodb";
+import {isLocalUser} from "../data.js";
+import {Event} from "../events.js";
+import {Config} from "../config.js";
+
+export let modelsCollection, datasCollection, filesCollection, packsCollection;
+
+export {ObjectId};
+
+let engine, logger, currentDb
+
+let colls= [];
+export async function onInit(defaultEngine) {
+    engine = defaultEngine;
+    logger = engine.getComponent(Logger);
+
+    currentDb = MongoDatabase();
+    modelsCollection = getCollection("models");
+    datasCollection = getCollection(Config.Get('dataCollection', 'datas'));
+    filesCollection = getCollection("files");
+    packsCollection = getCollection("packs");
+
+
+    colls = await (currentDb.listCollections()).toArray();
+
+    await Event.Trigger("OnDatabaseLoaded", "system", "calls", engine)
+    logger.info("MongoDB collections loaded.");
+}
+
+export const getCollections= async (forceRefresh)=>{
+    if( !forceRefresh )
+        return colls;
+    colls = await currentDb.listCollections().toArray();
+}
+
+export const createCollection = async (coll)=>{
+    const found =colls.find(f => f.name === coll);
+    if( found){
+        return getCollection(coll);
+    }
+    return await currentDb.createCollection(coll);
+}
+
+export const isObjectId = (id) => {
+    return (typeof(id) === 'string' && id.match(/^[0-9a-fA-F]{24}$/));
+};
+
+
+export const getCollection = (str) => {
+    if (typeof str !== 'string') {
+        logger?.error(`[MongoDB] Tentative d'accès à une collection avec un type invalide: ${typeof str}`);
+        throw new Error("Le nom de la collection doit être une chaîne de caractères.");
+    }
+    return currentDb.collection(str);
+}
+
+export const getDatabase = () => {
+    return currentDb;
+}
+
+// New function to determine the collection name for a user
+export const getUserCollectionName = async (user) => {
+    const feat = await engine.userProvider.hasFeature(user, 'indexes');
+    const dataCollectionName = Config.Get('dataCollection', 'datas');
+    return feat ? (isLocalUser(user) ? `${dataCollectionName}_${user._user}` :`${dataCollectionName}_${user.username}` ) : dataCollectionName;
+};
+
+
+// Modify existing functions to use the correct collection
+export const getCollectionForUser = async (user) => {
+    const collectionName = await getUserCollectionName(user);
+    return getCollection(collectionName);
+};

package/src/modules/user.js

@@ -68,7 +68,8 @@ export const middlewareAuthenticator = async (req, res, next) => {
     }
 
     try {
-        // 1. On demande au provider (votre PrimalsUserProvider) d'identifier l'utilisateur
+        const logger = engine.getComponent(Logger);
+        // 1. On demande au provider d'identifier l'utilisateur
         await engine.userProvider.initiateUser(req);
 
         // 2. On vérifie simplement si le provider a attaché un utilisateur
@@ -344,6 +345,15 @@ export async function getEnv(user){
     return envObject;
 }
 
+export function getInternalSmtpConfig(){
+    const cfg = Config.Get('emailDefaultConfig', emailDefaultConfig);
+    cfg.host = process.env.SMTP_HOST || cfg.host;
+    cfg.port = process.env.SMTP_PORT || cfg.port;
+    cfg.user = process.env.SMTP_USER || cfg.user;
+    cfg.pass = process.env.SMTP_PASS || cfg.pass;
+    return cfg;
+}
+
 export async function getSmtpConfig(user) {
 
     const cfg = Config.Get('emailDefaultConfig', emailDefaultConfig);
@@ -358,8 +368,14 @@ export async function getSmtpConfig(user) {
         acc[variable.name.replace('SMTP_', '').toLowerCase()] = variable.value;
         return acc;
     }, {});
+
     if( !smtpConfig.port )
         smtpConfig.port = cfg.port;
-
+    if( !smtpConfig.host )
+        smtpConfig.host = cfg.host;
+    if( !smtpConfig.user )
+        smtpConfig.user = cfg.user;
+    if( !smtpConfig.pass )
+        smtpConfig.pass = cfg.pass;
     return smtpConfig;
 }

package/src/modules/worker-script-runner.js

@@ -0,0 +1,97 @@
+import { parentPort } from 'worker_threads';
+
+let callIdCounter = 0;
+const pendingCalls = new Map();
+
+/**
+ * Appelle une fonction sur le thread principal et attend la réponse.
+ * @param {string} service - Le nom du service (ex: 'db').
+ * @param {string} method - Le nom de la méthode (ex: 'find').
+ * @param  {...any} args - Les arguments de la méthode.
+ * @returns {Promise<any>}
+ */
+function callHost(service, method, ...args) {
+    return new Promise((resolve, reject) => {
+        const callId = callIdCounter++;
+        pendingCalls.set(callId, { resolve, reject });
+        parentPort.postMessage({ type: 'call', callId, service, method, args });
+    });
+}
+
+// API exposée au script de l'utilisateur
+const db = {
+    create: (model, data) => callHost('db', 'create', model, data),
+    find: (model, filter, options) => callHost('db', 'find', model, filter, options),
+    findOne: (model, filter) => callHost('db', 'findOne', model, filter),
+    update: (model, filter, update) => callHost('db', 'update', model, filter, update),
+    delete: (model, filter) => callHost('db', 'delete', model, filter),
+};
+
+const workflow = {
+    run: (name, context) => callHost('workflow', 'run', name, context),
+};
+
+const logger = {
+    info: (...args) => callHost('log', 'info', ...args),
+    warn: (...args) => callHost('log', 'warn', ...args),
+    error: (...args) => callHost('log', 'error', ...args),
+};
+
+const env = {
+    get: (name) => callHost('env', 'get', name),
+    getAll: () => callHost('env', 'getAll'),
+};
+
+const http = {
+    request: (method, url, options) => callHost('http', 'request', method, url, options),
+};
+
+/**
+ * Exécute le code utilisateur dans un scope sécurisé.
+ * @param {string} code - Le code à exécuter.
+ * @param {object} context - Le contexte du workflow.
+ */
+async function runUserCode(code, context) {
+    // Crée une fonction asynchrone avec le code utilisateur.
+    // Les variables `db`, `logger`, `context`, etc., sont disponibles dans son scope.
+    const userFunction = new Function('db', 'workflow', 'logger', 'env', 'http', 'context', `return (async () => { ${code} })();`);
+
+    // Appelle la fonction avec l'API sandboxed.
+    return userFunction(db, workflow, logger, env, http, context);
+}
+
+// Gestionnaire de messages unique pour le worker
+parentPort.on('message', (msg) => {
+    // Message initial pour démarrer l'exécution
+    if (msg.code) {
+        // Le worker ne doit pas se terminer tant que le code n'est pas fini.
+        parentPort.ref();
+        runUserCode(msg.code, msg.context)
+            .then(result => {
+                parentPort.postMessage({ type: 'done', result });
+            })
+            .catch(e => {
+                parentPort.postMessage({ type: 'error', error: e.message });
+            })
+            .finally(() => {
+                // Une fois terminé, le worker peut se fermer.
+                parentPort.unref();
+            });
+    }
+    // Message de réponse à un appel `callHost`
+    else if (msg.type === 'response') {
+        const { callId, result, error } = msg;
+        if (pendingCalls.has(callId)) {
+            const { resolve, reject } = pendingCalls.get(callId);
+            if (error) {
+                reject(new Error(error));
+            } else {
+                resolve(result);
+            }
+            pendingCalls.delete(callId);
+        }
+    } else if (msg.type === 'call') {
+        // Ce cas ne devrait pas arriver (le worker envoie 'call', il ne le reçoit pas),
+        // mais on le laisse pour la robustesse.
+    }
+});

package/src/modules/workflow.js

@@ -1,8 +1,7 @@
 import {getCollection, getCollectionForUser, isObjectId} from "./mongodb.js";
 import schedule from "node-schedule";
 import {ObjectId} from "mongodb";
-
-import ivm from 'isolated-vm';
+import { Worker } from 'worker_threads';
 
 import {Logger} from "../gameObject.js";
 import {deleteData, getModel, insertData, patchData, searchData} from "./data/index.js";
@@ -19,7 +18,22 @@ import { providers } from "./assistant/constants.js";
 import { getAIProvider } from "./assistant/providers.js";
 import {Config} from "../config.js";
 import {safeAssignObject} from "../core.js";
-import {Event} from "../events.js";
+
+// Add Node.js path utilities for worker_threads
+import { fileURLToPath, URL } from 'node:url';
+import path from "node:path";
+let executionEngine = { type: null, module: null };
+try {
+    // Tentative de chargement de 'isolated-vm'.
+    // Si cela échoue (ex: incompatibilité d'architecture, build manquant),
+    // le serveur pourra quand même démarrer.
+
+    const ivm = (await import(/* @vite-ignore */ 'isolated-vm')).default;
+    executionEngine = { type: 'isolated-vm', module: ivm };
+} catch (e) {
+    executionEngine = { type: 'worker_threads', module: null };
+    console.warn(`[Module] Le module 'isolated-vm' n'a pas pu être chargé. L'action de workflow 'ExecuteScript' sera désactivée. Erreur : ${e.message}`);
+}
 
 /**
  * Récupère une valeur imbriquée dans un objet (ex: 'user.address.city').
@@ -383,7 +397,103 @@ async function handleWaitAction(actionDef, contextData, user) {
 }
 
 
-export async function executeSafeJavascript(actionDef, context, user) {
+async function executeWithWorkerThreads(actionDef, context, user) {
+    const TIMEOUT = 5000;
+    const collectedLogs = [];
+    const code = actionDef.script;
+    // Contexte sécurisé
+    const safeContext = JSON.parse(JSON.stringify(context));
+
+    return new Promise((resolve, reject) => {
+        // Construct an absolute file path for the worker. This is the most reliable method,
+        // ensuring Node.js loads the script directly without ambiguity.
+        const workerPath = path.dirname('src/workers/worker-script-runner.js');
+
+        const worker = new Worker(workerPath);
+
+        const timeoutId = setTimeout(() => {
+            worker.terminate();
+            const errorMessage = `Script execution timed out after ${TIMEOUT}ms.`;
+            collectedLogs.push({level: 'critical', message: errorMessage, timestamp: new Date().toISOString()});
+            resolve({success: false, message: errorMessage, logs: collectedLogs});
+        }, TIMEOUT);
+
+        worker.on('message', async (msg) => {
+            if (msg.type === 'call') {
+                const {callId, service, method, args} = msg;
+                try {
+                    let result;
+                    // Recréez ici la logique d'appel des fonctions natives
+                    // C'est un pont entre le worker et votre application principale.
+                    if (service === 'db') {
+                        if (method === 'find') result = await searchData({
+                            model: args[0],
+                            filter: args[1], ...args[2]
+                        }, user);
+                        else if (method === 'findOne') result = (await searchData({
+                            model: args[0],
+                            filter: args[1],
+                            limit: 1
+                        }, user))?.data?.[0] || null;
+                        else if (method === 'create') result = await insertData(args[0], args[1], {}, user, false);
+                        else if (method === 'update') result = await patchData(args[0], args[1], args[2], {}, user, false);
+                        else if (method === 'delete') result = await deleteData(args[0], args[1], user, false);
+                    } else if (service === 'workflow') {
+                        if (method === 'run') result = await runWorkflowByName(args[0], args[1], user);
+                    } else if (service === 'log') {
+                        const message = args.join(' ');
+                        collectedLogs.push({level: method, message, timestamp: new Date().toISOString()});
+                        logger.trace(`[Worker Script Log - ${method}]`, message);
+                        result = {success: true};
+                    } else if (service === 'env') {
+                        if (method === 'get') result = (await searchData({
+                            model: 'env',
+                            filter: {name: args[0]},
+                            limit: 1
+                        }, user))?.data?.[0]?.value || null;
+                        else if (method === 'getAll') result = await getEnv(user);
+                    } else if (service === 'http') {
+                        const [methodHttp, url, options] = args;
+                        const fetchOptions = {
+                            method: methodHttp.toUpperCase(),
+                            headers: options.headers || {},
+                            body: options.body ? (typeof options.body === 'object' ? JSON.stringify(options.body) : options.body) : undefined
+                        };
+                        const response = await fetch(url, fetchOptions);
+                        const responseBody = await response.json().catch(() => response.text());
+                        result = {success: response.ok, status: response.status, body: responseBody};
+                    }
+
+                    worker.postMessage({type: 'response', callId, result});
+                } catch (error) {
+                    worker.postMessage({type: 'response', callId, error: error.message});
+                }
+            } else if (msg.type === 'done') {
+                clearTimeout(timeoutId);
+                worker.terminate();
+                resolve({success: true, data: msg.result, logs: collectedLogs, updatedContext: {result: msg.result}});
+            } else if (msg.type === 'error') {
+                clearTimeout(timeoutId);
+                worker.terminate();
+                const errorMessage = `Script execution failed: ${msg.error}`;
+                collectedLogs.push({level: 'critical', message: errorMessage, timestamp: new Date().toISOString()});
+                resolve({success: false, message: errorMessage, logs: collectedLogs});
+            }
+        });
+
+        worker.on('error', (err) => {
+            clearTimeout(timeoutId);
+            const errorMessage = `Worker error: ${err.message}`;
+            collectedLogs.push({level: 'critical', message: errorMessage, timestamp: new Date().toISOString()});
+            resolve({success: false, message: errorMessage, logs: collectedLogs});
+        });
+
+        worker.postMessage({code, context: safeContext});
+    });
+}
+
+async function executeWithIsolatedVm(actionDef, context, user) {
+    const ivm = executionEngine.module;
     const code = actionDef.script;
     const collectedLogs = [];
     const isolate = new ivm.Isolate({ memoryLimit: 128 }); // 128MB memory limit
@@ -477,43 +587,43 @@ export async function executeSafeJavascript(actionDef, context, user) {
 
         // Exécution
         const fullScript = `
-            const normalizeArgs = args => args.map(arg => {
-                if (typeof arg === 'object' && arg !== null) {
-                    return JSON.stringify(arg); // Convert objects to strings
-                }
-                return arg;
-            });
-            const db = {
-                create: (...args) => _db_create.applySyncPromise(null, normalizeArgs(args)),
-                find: (...args) => _db_find.applySyncPromise(null, normalizeArgs(args)),
-                findOne: (...args) => _db_findOne.applySyncPromise(null, normalizeArgs(args)),
-                update: (...args) => _db_update.applySyncPromise(null, normalizeArgs(args)),
-                delete: (...args) => _db_delete.applySyncPromise(null, normalizeArgs(args))
-            };
-            
-            const workflow = {
-                run: (...args) => _workflow_run.applySyncPromise(null, normalizeArgs(args))
-            };
-
-            const logger = {
-                info: _log_info,
-                warn: _log_warn,
-                error: _log_error
-            };
-
-            const env = {
-                get: _env_get,
-                getAll: _env_get_all
-            };
-            
-            const http = {
-                request: (...args) => _http_request.applySyncPromise(null, normalizeArgs(args))
-            };
-
-            (async function() {
-                ${code}
-            })();
-        `;
+             const normalizeArgs = args => args.map(arg => {
+                 if (typeof arg === 'object' && arg !== null) {
+                     return JSON.stringify(arg); // Convert objects to strings
+                 }
+                 return arg;
+             });
+             const db = {
+                 create: (...args) => _db_create.applySyncPromise(null, normalizeArgs(args)),
+                 find: (...args) => _db_find.applySyncPromise(null, normalizeArgs(args)),
+                 findOne: (...args) => _db_findOne.applySyncPromise(null, normalizeArgs(args)),
+                 update: (...args) => _db_update.applySyncPromise(null, normalizeArgs(args)),
+                 delete: (...args) => _db_delete.applySyncPromise(null, normalizeArgs(args))
+             };
+             
+             const workflow = {
+                 run: (...args) => _workflow_run.applySyncPromise(null, normalizeArgs(args))
+             };
+ 
+             const logger = {
+                 info: _log_info,
+                 warn: _log_warn,
+                 error: _log_error
+             };
+ 
+             const env = {
+                 get: _env_get,
+                 getAll: _env_get_all
+             };
+             
+             const http = {
+                 request: (...args) => _http_request.applySyncPromise(null, normalizeArgs(args))
+             };
+ 
+             (async function() {
+                 ${code}
+             })();
+         `;
 
         const TIMEOUT = 5000;
         const script = await isolate.compileScript(fullScript, { timeout: TIMEOUT });
@@ -556,6 +666,22 @@ export async function executeSafeJavascript(actionDef, context, user) {
     }
 }
 
+export async function executeSafeJavascript(actionDef, context, user) {
+    // Vérifie si un moteur d'exécution est disponible.
+    if (!executionEngine.type) {
+        const errorMessage = "L'action 'ExecuteScript' est désactivée car aucun moteur d'exécution (isolated-vm ou fallback) n'a pu être initialisé.";
+        logger.error(`[Script Engine] ${errorMessage}`);
+        return { success: false, message: errorMessage, logs: [{ level: 'critical', message: errorMessage, timestamp: new Date().toISOString() }] };
+    }
+
+    logger.info(`[Script Engine] Using '${executionEngine.type}' for script execution.`);
+
+    if (executionEngine.type === 'isolated-vm') {
+        return executeWithIsolatedVm(actionDef, context, user);
+    } else { // 'worker_threads'
+        return executeWithWorkerThreads(actionDef, context, user);
+    }
+}
 /**
  * Handles the 'HttpRequest' workflow action.
  * Sends an HTTP request to a specified URL with substituted data using native fetch.
@@ -567,18 +693,17 @@ export async function executeSafeJavascript(actionDef, context, user) {
  * @returns {Promise<{success: boolean, message?: string, responseStatus?: number, responseBody?: any}>} - Result of the action.
  */
 async function handleHttpRequestAction(actionDef, contextData, user, dbCollection) {
-    const { name: actionName, _id: actionId, url, method = 'POST', headers: headersTemplate, body: bodyTemplate } = actionDef;
-
-    // 1. Basic Validation
-    if (!url) {
-        const msg = `[handleHttpRequestAction] Action ${actionName} (${actionId}): Missing 'url'.`;
-        logger.error(msg);
-        return { success: false, message: msg };
-    }
-
-    logger.info(`[handleHttpRequestAction] Action ${actionName} (${actionId}): Executing webhook. Method: ${method}`);
 
     try {
+        const {
+            method = 'GET',
+            url,
+            headers: headersTemplate,
+            body: bodyTemplate,
+            name: actionName = 'Unnamed Action',
+            _id: actionId = 'unknown'
+        } = actionDef;
+
         // 2. Substitute Variables
         const substitutedUrl = await substituteVariables(url, contextData, user);
         let substitutedHeadersString;
@@ -1423,7 +1548,7 @@ export async function processWorkflowRun(workflowRunId, user) {
         const mw = Config.Get('maxWorkflowSteps', maxWorkflowSteps);
         while (currentStepId) {
             if (stepCount++ >= mw) {
-                return await logError(`Maximum workflow step executions exceeded (${maxWorkflowSteps} max).`);
+                return await logError(`Maximum workflow step executions exceeded (${mw} max).`);
             }
 
             const execCount = (stepExecutionsCount[currentStepId] || 0) + 1;