data-primals-engine 1.0.11 → 1.1.1

package/src/modules/file.js

@@ -3,7 +3,6 @@
 import {maxPrivateFileSize, megabytes} from "../constants.js";
 import {isLocalUser} from "../data.js";
 import i18n from "data-primals-engine/i18n";
-import {getUserStorageLimit} from "../user.js";
 import {getCollection} from "./mongodb.js";
 import {getFileExtension, isGUID, uuidv4} from "../core.js";
 import path from "node:path";
@@ -14,9 +13,6 @@ import crypto from "node:crypto";
 import * as tar from "tar";
 import {promisify} from "node:util";
 import {calculateTotalUserStorageUsage, hasPermission} from "./user.js";
-import {Logger} from "../gameObject.js";
-import YAML from "yaml";
-import swaggerUi from "swagger-ui-express";
 
 const pbkdf2Async = promisify(crypto.pbkdf2);
 
@@ -56,7 +52,7 @@ export const addFile = async (file, user) => {
 
     const incomingDataSize = file.size;
 
-    const userStorageLimit = getUserStorageLimit(user);
+    const userStorageLimit = await engine.userProvider.getUserStorageLimit(user);
     const currentStorageUsage = await calculateTotalUserStorageUsage(user);
 
     if (currentStorageUsage + incomingDataSize > userStorageLimit) {
@@ -194,6 +190,7 @@ export async function decryptFile(filePath, password) {
     }
 }
 
+let engine;
 export async function onInit(defaultEngine) {
-
+    engine = defaultEngine;
 }

package/src/modules/mongodb.js

@@ -1,9 +1,7 @@
 
 import process from "process";
-import {MongoClient as InternalMongoClient} from "mongodb";
 import {Logger} from "../gameObject.js";
-import {MongoClient, MongoDatabase} from "../engine.js";
-import * as tls from "node:tls";
+import {MongoDatabase} from "../engine.js";
 import fs from "node:fs";
 
 export let modelsCollection, datasCollection, filesCollection, packsCollection;
@@ -46,14 +44,15 @@ export const getCollection = (str) => {
 
 
 // New function to determine the collection name for a user
-export const getUserCollectionName = (user) => {
-    return user?.userPlan === 'premium' ? `datas_${user.username}` : 'datas';
+export const getUserCollectionName = async (user) => {
+    const feat = await engine.userProvider.hasFeature(user, 'indexes');
+    return feat ? `datas_${user.username}` : 'datas';
 };
 
 
 // Modify existing functions to use the correct collection
-export const getCollectionForUser = (user) => {
-    const collectionName = getUserCollectionName(user);
+export const getCollectionForUser = async (user) => {
+    const collectionName = await getUserCollectionName(user);
     return getCollection(collectionName);
 };
 

package/src/modules/user.js

@@ -1,7 +1,6 @@
 import i18n from "data-primals-engine/i18n";
-import {MongoClient, MongoDatabase} from "../engine.js";
+import {MongoDatabase} from "../engine.js";
 import {getCollection, getCollectionForUser, getUserCollectionName} from "./mongodb.js";
-import {dbName, plans} from "../constants.js";
 import {isLocalUser} from "../data.js";
 import {ObjectId} from "mongodb";
 import {getAPILang} from "./data.js";
@@ -20,10 +19,10 @@ export const userInitiator = async (req, res, next) => {
     // set current lang for user
     i18n.changeLanguage(lang);
 
-    if (req.me.userPlan === 'premium') {
+    if (await engine.userProvider.hasFeature(req.me, 'indexes')) {
         const collections = await MongoDatabase.listCollections().toArray();
         const collectionNames = collections.map(c => c.name);
-        const coll = getUserCollectionName(req.me);
+        const coll = await getUserCollectionName(req.me);
         if (collectionNames.includes(coll)) {
             const collection = await MongoDatabase.createCollection(coll);
             const indexes = await collection.indexes();
@@ -83,33 +82,11 @@ export const generateLimiter = rateLimit({
     }
 });
 
-const freeSearchLimiter = rateLimit({
-    windowMs: 1000 * 3600,
-    limit: plans.free.requestLimitPerHour,
-    standardHeaders: true,
-    legacyHeaders: false,
-});
-const premiumSearchLimiter = rateLimit({
-    windowMs: 1000 * 3600,
-    limit: plans.premium.requestLimitPerHour,
-    standardHeaders: true,
-    legacyHeaders: false,
-});
-
-export const myFreePremiumAnonymousLimiter = async function (req, res, next) {
-    const user = req.me;
-    if (user?.userPlan === "premium") {
-        return premiumSearchLimiter(req, res, next);
-    }
-    return freeSearchLimiter(req, res, next);
-};
 
 let logger,engine;
 export async function onInit(defaultEngine) {
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
-
-
 }
 
 export async function hasPermission(permissionNames, user) {
@@ -119,7 +96,7 @@ export async function hasPermission(permissionNames, user) {
     try {
         // Si on a une string on le transforme en tableau.
         const permissionNamesArray = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
-        const collection = getCollectionForUser(user);
+        const collection = await getCollectionForUser(user);
 
         const job = [
             {
@@ -131,39 +108,39 @@ export async function hasPermission(permissionNames, user) {
                             $match: {
                                 $expr: {
                                     $and: [
-                                        { $in: ['$_id', '$$rolesIds'] },
-                                    ],
-                                },
-                            },
+                                        { $in: ['$_id', '$$rolesIds'] }
+                                    ]
+                                }
+                            }
                         },
                         {
                             $lookup: {
                                 from: 'datas',
                                 let: { rolePermissions: {
-                                        "$map": {
-                                            "input": "$permissions",
-                                            "in": { "$toObjectId": "$$this" }
-                                        }
-                                    } },
+                                    "$map": {
+                                        "input": "$permissions",
+                                        "in": { "$toObjectId": "$$this" }
+                                    }
+                                } },
                                 pipeline: [
                                     {
                                         $match: {
                                             $expr: {
                                                 $and: [
-                                                    { $in: ['$_id', '$$rolePermissions'] },
-                                                ],
-                                            },
-                                        },
+                                                    { $in: ['$_id', '$$rolePermissions'] }
+                                                ]
+                                            }
+                                        }
                                     },
-                                    { $limit: 1 },
+                                    { $limit: 1 }
                                 ],
-                                as: 'permissions',
-                            },
+                                as: 'permissions'
+                            }
                         },
-                        { $unwind: { path: '$permissions', preserveNullAndEmptyArrays: true } },
+                        { $unwind: { path: '$permissions', preserveNullAndEmptyArrays: true } }
                     ],
-                    as: 'roles',
-                },
+                    as: 'roles'
+                }
             },
             { $unwind: { path: '$roles', preserveNullAndEmptyArrays: true } },
             { $match: { 'roles.permissions.name': { $in: permissionNamesArray } } }, // Match if permissions.name in array
@@ -186,7 +163,7 @@ export async function hasPermission(permissionNames, user) {
  */
 export async function calculateTotalUserStorageUsage(user) {
     const userId = user._user || user.username;
-    const datasCollection = getCollectionForUser(user);
+    const datasCollection = await getCollectionForUser(user);
     const filesCollection = getCollection("files");
 
     // Pipeline pour calculer la taille des documents de données

package/src/modules/workflow.js

@@ -4,17 +4,16 @@ import schedule from "node-schedule";
 import {ObjectId} from "mongodb";
 import crypto from "node:crypto";
 
+import {VM, VMScript} from 'vm2';
 import {Logger} from "../gameObject.js";
-import {deleteData, editData, insertData, patchData, searchData} from "./data.js";
+import {deleteData, 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 {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;
@@ -131,7 +130,7 @@ export async function scheduleWorkflowTriggers() {
         // Trouver tous les workflows actifs avec une cronExpression définie
         const workflowsToSchedule = await datasCollection.find({
             _model: 'workflowTrigger',
-            cronExpression: { $exists: true, $ne: "" },
+            cronExpression: { $exists: true, $ne: "" }
             // Ajoutez d'autres conditions si nécessaire (ex: active: true)
         }).toArray();
 
@@ -181,6 +180,69 @@ 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
+ */
+async function executeSafeJavascript(actionDef, context) {
+    const code = actionDef.script;
+    const vm = new VM({
+        timeout: 1000, // Time out after 1 second
+        sandbox: context, // Pass the context object
+        console: 'redirect', // Redirect console output
+        require: false, // Disable require
+        wasm: false // disable WebAssembly
+    });
+
+    try {
+        const script = new VMScript(code);
+        return vm.run(script);
+    } catch (error) {
+        console.error("Error executing script:", error);
+        throw error; // or return an error object
+    }
+}
+
 /**
  * Handles the 'Webhook' workflow action.
  * Sends an HTTP request to a specified URL with substituted data using native fetch.
@@ -270,7 +332,7 @@ async function handleWebhookAction(actionDef, contextData, user, dbCollection) {
         // 4. Prepare Fetch Options
         const fetchOptions = {
             method: method.toUpperCase(),
-            headers: headersObject, // Native fetch accepts an object directly
+            headers: headersObject // Native fetch accepts an object directly
         };
 
         if (bodyObject !== null && ['POST', 'PUT', 'PATCH'].includes(fetchOptions.method)) {
@@ -649,32 +711,36 @@ export async function executeStepAction(actionDef, contextData, user, dbCollecti
     try {
         let result;
         switch (actionDef.type) {
-            case 'Log':
-                logger.info(`[Workflow Log Action] Action: ${actionDef.name}. Contexte:`, contextData);
-                result = { success: true, message: 'Log action executed successfully.' }; // <--- CORRECTION
-                break;
-            case 'Webhook':
-                result = await handleWebhookAction(actionDef, contextData, user, dbCollection);
-                break;
-            case 'CreateData':
-                result = await handleCreateDataAction(actionDef, contextData, user, dbCollection);
-                break;
-            case 'UpdateData':
-                result = await handleUpdateDataAction(actionDef, contextData, user);
-                break;
-            case 'DeleteData':
-                result = await handleDeleteDataAction(actionDef, contextData, user, dbCollection);
-                break;
-            case 'GenerateAIContent':
-                result = await executeGenerateAIContentAction(actionDef, contextData, user);
-                break;
-            case 'SendEmail':
-                result = await handleSendEmailAction(actionDef, contextData, user);
-                break;
+        case 'Log':
+            logger.info(`[Workflow Log Action] Action: ${actionDef.name}. Contexte:`, contextData);
+            result = { success: true, message: 'Log action executed successfully.' }; // <--- CORRECTION
+            break;
+        case 'Webhook':
+            result = await handleWebhookAction(actionDef, contextData, user, dbCollection);
+            break;
+        case 'CreateData':
+            result = await handleCreateDataAction(actionDef, contextData, user, dbCollection);
+            break;
+        case 'UpdateData':
+            result = await handleUpdateDataAction(actionDef, contextData, user);
+            break;
+        case 'DeleteData':
+            result = await handleDeleteDataAction(actionDef, contextData, user, dbCollection);
+            break;
+        case 'GenerateAIContent':
+            result = await executeGenerateAIContentAction(actionDef, contextData, user);
+            break;
+        case 'SendEmail':
+            result = await handleSendEmailAction(actionDef, contextData, user);
+            break;
+        case 'ExecuteScript':
+            result = await executeSafeJavascript(actionDef, contextData);
+            break;
+
             // ... autres cases à venir ...
-            default:
-                logger.error(`[executeStepAction] Unknown action type: ${actionDef.type}`);
-                return { success: false, message: `Unknown action type: ${actionDef.type}` };
+        default:
+            logger.error(`[executeStepAction] Unknown action type: ${actionDef.type}`);
+            return { success: false, message: `Unknown action type: ${actionDef.type}` };
         }
         return result;
     } catch (error) {
@@ -749,7 +815,7 @@ async function resolvePathValue(pathString, initialContext, user) {
 
     let currentModelName = initialContext._model;
     let currentDocId = new ObjectId(initialContext._id);
-    const collection = getCollectionForUser(user);
+    const collection = await getCollectionForUser(user);
 
     // Construire le pipeline d'agrégation
     const pipeline = [
@@ -862,7 +928,7 @@ export async function substituteVariables(template, contextData, user) {
     // --- À partir d'ici, nous savons que `template` est une chaîne de caractères ---
 
     // 4. Construire le contexte complet pour la substitution
-    const dbCollection = getCollectionForUser(user);
+    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 }), {});
 
@@ -972,7 +1038,7 @@ export async function triggerWorkflows(triggerData, user, eventType)  {
         console.log(`[Workflow Trigger] Event: ${eventType}, Model: ${targetModelName}${dataId ? `, Data ID: ${dataId}` : ''}, User: ${user.username}`);
 
         try {
-            const dbCollection = getCollectionForUser(user); // Collection des données utilisateur
+            const dbCollection = await getCollectionForUser(user); // Collection des données utilisateur
 
             // 1. Trouver les WorkflowTriggers pertinents
             const workflowTriggers = await dbCollection.find({
@@ -1008,29 +1074,29 @@ export async function triggerWorkflows(triggerData, user, eventType)  {
                         continue; // Passer au trigger suivant si le filtre est invalide
                     }
 
-                        try {
-                            const finalFilter = {
-                                '$and': [
-                                    dataFilterCondition                      // Applique la condition du trigger
-                                ]
-                            };
-
-                            console.debug(`[Workflow Trigger] Vérification dataFilter pour trigger ${trigger._id} avec filtre combiné:`, JSON.stringify(finalFilter));
-
-                            // Exécuter la vérification dans la base de données
-                            // Utilisation de countDocuments pour une vérification rapide
-                            const matchCount = await searchData({ user, query: { model: targetModelName, filter: finalFilter, limit: 1 } });
-
-                            if (!matchCount.count) {
-                                console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter non satisfait par la donnée ${dataId}. WorkflowRun non créé.`);
-                                continue; // Passer au trigger suivant
-                            } else {
-                                console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter satisfait par la donnée ${dataId}.`);
-                            }
-                        } catch (filterError) {
-                            console.error(`[Workflow Trigger] Erreur lors de la conversion ou de l'exécution du dataFilter pour le trigger ${trigger._id}:`, filterError);
-                            continue; // Ne pas créer en cas d'erreur de filtre
+                    try {
+                        const finalFilter = {
+                            '$and': [
+                                dataFilterCondition                      // Applique la condition du trigger
+                            ]
+                        };
+
+                        console.debug(`[Workflow Trigger] Vérification dataFilter pour trigger ${trigger._id} avec filtre combiné:`, JSON.stringify(finalFilter));
+
+                        // Exécuter la vérification dans la base de données
+                        // Utilisation de countDocuments pour une vérification rapide
+                        const matchCount = await searchData({ user, query: { model: targetModelName, filter: finalFilter, limit: 1 } });
+
+                        if (!matchCount.count) {
+                            console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter non satisfait par la donnée ${dataId}. WorkflowRun non créé.`);
+                            continue; // Passer au trigger suivant
+                        } else {
+                            console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter satisfait par la donnée ${dataId}.`);
                         }
+                    } catch (filterError) {
+                        console.error(`[Workflow Trigger] Erreur lors de la conversion ou de l'exécution du dataFilter pour le trigger ${trigger._id}:`, filterError);
+                        continue; // Ne pas créer en cas d'erreur de filtre
+                    }
                 } // Fin de la vérification dataFilter
 
                 // 4. Si les filtres (eventType, dataFilter) sont passés, créer l'instance workflowRun
@@ -1087,9 +1153,9 @@ export async function triggerWorkflows(triggerData, user, eventType)  {
     }
 
     return new Promise((resolve) => setTimeout(async () => {
-           await trigger(triggerData, user, eventType);
-           resolve();
-        }, 0)
+        await trigger(triggerData, user, eventType);
+        resolve();
+    }, 0)
     );
 }
 
@@ -1105,7 +1171,7 @@ export async function triggerWorkflows(triggerData, user, eventType)  {
 // C:/Dev/hackersonline-engine/server/src/modules/workflow.js
 
 export async function processWorkflowRun(workflowRunId, user) {
-    const dbCollection = getCollectionForUser(user);
+    const dbCollection = await getCollectionForUser(user);
     const runId = typeof workflowRunId === 'string' ? new ObjectId(workflowRunId) : workflowRunId;
 
     logger.info(`[processWorkflowRun] Starting processing for workflowRun ID: ${runId}`);
@@ -1290,7 +1356,7 @@ async function executeGenerateAIContentAction(action, context, user) {
 
     const providers = {
         "OpenAI" : "OPENAI_API_KEY",
-        "Google": "GOOGLE_API_KEY",
+        "Google": "GOOGLE_API_KEY"
     }
     const envKeyName = providers[aiProvider];
     if( !envKeyName ) {
@@ -1298,7 +1364,7 @@ async function executeGenerateAIContentAction(action, context, user) {
     }
 
     // Cherche d'abord dans les variables d'environnement de l'utilisateur
-    const envCollection = getCollectionForUser(user);
+    const envCollection = await getCollectionForUser(user);
     const userEnvVar = await envCollection.findOne({ _model: 'env', name: envKeyName, _user: user.username });
 
     if (userEnvVar && userEnvVar.value) {
@@ -1319,14 +1385,14 @@ async function executeGenerateAIContentAction(action, context, user) {
     let llm;
     try {
         switch (aiProvider) {
-            case 'OpenAI':
-                llm = new ChatOpenAI({ apiKey, modelName: aiModel, temperature: 0.7 });
-                break;
-            case 'GoogleGemini':
-                llm = new ChatGoogleGenerativeAI({ apiKey, modelName: aiModel, temperature: 0.7 });
-                break;
-            default:
-                throw new Error(`Fournisseur IA non supporté : ${aiProvider}`);
+        case 'OpenAI':
+            llm = new ChatOpenAI({ apiKey, modelName: aiModel, temperature: 0.7 });
+            break;
+        case 'GoogleGemini':
+            llm = new ChatGoogleGenerativeAI({ apiKey, modelName: aiModel, temperature: 0.7 });
+            break;
+        default:
+            throw new Error(`Fournisseur IA non supporté : ${aiProvider}`);
         }
     } catch (initError) {
         const message = `Échec de l'initialisation du client IA pour ${aiProvider}: ${initError.message}`;
@@ -1413,7 +1479,7 @@ async function handleSendEmailAction(action, triggerData, user) {
         // 3. Préparer les données pour sendEmail
         const emailData = {
             title: rsubject,
-            content: rbody,
+            content: rbody
         };
 
         await sendEmail(rto, emailData, smtpConfig, user.lang);

package/src/openai.jobs.js

@@ -121,10 +121,10 @@ export const openaiJobModel = async (lang, txt, history, existingModels = []) =>
                 },
                 {
                     role: "user",
-                    content: typeof(txt) === 'string' ? txt.substring(0, 4096) : '',
+                    content: typeof(txt) === 'string' ? txt.substring(0, 4096) : ''
                 },
                 ...history
-            ],
+            ]
         });
 
         const aiResponse = completion.choices[0].message.content;