data-primals-engine 1.2.6-rc2 → 1.2.6

package/src/modules/data/data.js

@@ -1,6 +1,6 @@
 import {Logger} from "../../gameObject.js";
 import {BSON, ObjectId} from "mongodb";
-import {promisify} from 'node:util';
+import util, {promisify} from 'node:util';
 import crypto from "node:crypto";
 import {exec, execFile} from 'node:child_process';
 import sanitizeHtml from 'sanitize-html';
@@ -67,7 +67,6 @@ import {
 import NodeCache from "node-cache";
 import AWS from 'aws-sdk';
 import checkDiskSpace from "check-disk-space";
-import {Worker} from 'worker_threads';
 import {addFile,  removeFile} from "../file.js";
 import {downloadFromS3, getUserS3Config, listS3Backups, uploadToS3} from "../bucket.js";
 import {
@@ -78,7 +77,7 @@ import {getAllPacks} from "../../packs.js";
 import {Config} from "../../config.js";
 import {profiles} from "../../../client/src/constants.js";
 import {registerRoutes, sendSseToUser} from "./data.routes.js";
-import {importJobs, modelsCache, mongoDBWhitelist} from "./data.core.js";
+import {importJobs, modelsCache, mongoDBWhitelist, runCryptoWorkerTask, runImportExportWorker} from "./data.core.js";
 import readXlsxFile from "read-excel-file/node";
 
 let engine;
@@ -500,75 +499,6 @@ export const getAPILang = (langs) => {
     }, []).sort(((p,r) => p.quality < r.quality ? 1 : -1))?.[0].lang.split(/[-_]/)?.[0];
 }
 
-/**
- * Exécute une tâche d'import/export (parsing, stringify) dans un worker thread.
- * @param {('parse-json'|'parse-csv'|'stringify-json')} action - L'action à effectuer.
- * @param {object} payload - Les données nécessaires pour l'action.
- * @returns {Promise<any>} - Une promesse qui se résout avec les données traitées.
- */
-function runImportExportWorker(action, payload) {
-    return new Promise((resolve, reject) => {
-        const workerPath = path.resolve(process.cwd(), './src/workers/import-export-worker.js');
-        const worker = new Worker(workerPath);
-
-        worker.postMessage({ action, payload });
-
-        worker.on('message', (result) => {
-            if (result.success) {
-                resolve(result.data);
-            } else {
-                // Correction : On s'assure de toujours passer une chaîne de caractères à new Error()
-                const errorMessage = result.error || `Import/Export Worker failed with an unknown error. Action: ${action}.`;
-                reject(new Error(errorMessage));
-            }
-            worker.terminate();
-        });
-
-        worker.on('error', (err) => {
-            reject(err);
-            worker.terminate();
-        });
-
-        worker.on('exit', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Import/Export Worker stopped with exit code ${code}`));
-            }
-        });
-    });
-}
-/** Exécute une tâche de cryptographie dans un worker thread.
- * @param {('encrypt'|'decrypt'|'hash')} action - L'action à effectuer.
- * @param {object} payload - Les données nécessaires pour l'action.
- * @returns {Promise<any>} - Une promesse qui se résout avec le résultat (si pertinent).
- */
-function runCryptoWorkerTask(action, payload) {
-    return new Promise((resolve, reject) => {
-        const workerPath = path.resolve(process.cwd(), './src/workers/crypto-worker.js');
-        const worker = new Worker(workerPath);
-
-        worker.postMessage({ action, payload });
-
-        worker.on('message', (result) => {
-            if (result.success) {
-                resolve(result.data); // Résout avec les données (ex: le hash) ou undefined si pas de retour
-            } else {
-                reject(new Error(result.error));
-            }
-            worker.terminate();
-        });
-
-        worker.on('error', (err) => {
-            reject(err);
-            worker.terminate();
-        });
-
-        worker.on('exit', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Crypto Worker stopped with exit code ${code}`));
-            }
-        });
-    });
-}
 
 export function validateModelStructure(modelStructure) {
 
@@ -2111,22 +2041,41 @@ async function insertAndResolveRelations(doc, model, collection, me, idMap) {
 
     for (const field of model.fields) {
         if (field.type === 'relation' && field.relationFilter && docToProcess[field.name]) {
-            const relatedIds = Array.isArray(docToProcess[field.name]) ? docToProcess[field.name] : [docToProcess[field.name]];
-            for (const id of relatedIds) {
-                const targetCollection = await getCollectionForUser(me, field.targetModel);
-                const validationQuery = {
-                    _id: new ObjectId(id), // L'ID doit correspondre
-                    ...field.relationFilter // ET le document doit respecter le filtre
-                };
-                const relatedDoc = await targetCollection.findOne(validationQuery);
-                if (!relatedDoc) {
-                    // Si on ne trouve rien, c'est que l'ID est invalide ou ne respecte pas le filtre.
-                    throw new Error(`La valeur '${id}' pour le champ '${field.name}' ne respecte pas le filtre de relation défini.`);
-                }
+
+            const relatedIds = Array.isArray(docToProcess[field.name])
+                ? docToProcess[field.name]
+                : [docToProcess[field.name]];
+
+            // Préparer un filtre global : match si _id dans relatedIds ET respecte relationFilter
+            const validationQuery = {
+                $and: [
+                    { $in: ['$_id', relatedIds.map(id => ({ $toObjectId: id }))] },
+                    field.relationFilter
+                ]
+            };
+
+            const relatedDocs = await searchData({
+                filter: validationQuery,
+                model: field.relation,
+                limit: relatedIds.length
+            }, me);
+
+            if ((relatedDocs?.count || 0) !== relatedIds.length) {
+                const invalidIds = relatedIds.filter(id =>
+                    !relatedDocs.data.some(doc => doc._id.toString() === id.toString())
+                );
+                throw new Error(
+                    i18n.t(
+                        'api.data.relationFilterFailed',
+                        'Les valeurs {{values}} pour le champ {{field}} ne respectent pas le filtre de relation défini.',
+                        { field: field.name, values: invalidIds.join(', ') }
+                    )
+                );
             }
         }
     }
 
+
     // Insertion en conservant éventuellement l'ID original
     const result = docToProcess._id
         ? await collection.insertOne(docToProcess)
@@ -2366,28 +2315,37 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
         }
 
         for (const field of model.fields) {
-            // On ne vérifie que si un champ de relation avec un filtre est en cours de modification.
-            if (field.type === 'relation' && field.relationFilter && updateData[field.name] !== undefined) {
+            if (field.type === 'relation' && field.relationFilter && updateData[field.name]) {
+
                 const relatedIds = Array.isArray(updateData[field.name])
                     ? updateData[field.name]
-                    : (updateData[field.name] ? [updateData[field.name]] : []);
+                    : [updateData[field.name]];
 
-                for (const id of relatedIds) {
-                    if (!id || !isObjectId(id)) continue; // Ignorer les valeurs null/invalides
-
-                    const targetCollection = await getCollectionForUser(user, field.relation);
-
-                    const validationQuery = {
-                        _id: new ObjectId(id),
-                        ...field.relationFilter
-                    };
+                // Préparer un filtre global : match si _id dans relatedIds ET respecte relationFilter
+                const validationQuery = {
+                    $and: [
+                        { $in: ['$_id', relatedIds.map(id => ({ $toObjectId: id }))] },
+                        field.relationFilter
+                    ]
+                };
 
-                    const relatedDoc = await targetCollection.findOne(validationQuery);
+                const relatedDocs = await searchData({
+                    filter: validationQuery,
+                    model: field.relation,
+                    limit: relatedIds.length
+                }, user);
 
-                    if (!relatedDoc) {
-                        // Si on ne trouve rien, c'est que l'ID est invalide ou ne respecte pas le filtre.
-                        throw new Error(`La valeur '${id}' pour le champ '${field.name}' ne respecte pas le filtre de relation défini.`);
-                    }
+                if ((relatedDocs?.count || 0) !== relatedIds.length) {
+                    const invalidIds = relatedIds.filter(id =>
+                        !relatedDocs.data.some(doc => doc._id.toString() === id.toString())
+                    );
+                    throw new Error(
+                        i18n.t(
+                            'api.data.relationFilterFailed',
+                            'Les valeurs {{values}} pour le champ {{field}} ne respectent pas le filtre de relation défini.',
+                            { field: field.name, values: invalidIds.join(', ') }
+                        )
+                    );
                 }
             }
         }

package/src/modules/data/data.routes.js

@@ -40,10 +40,10 @@ import {tutorialsConfig} from "../../../client/src/tutorials.js";
 import {
     cancelAlerts, deleteData,
     dumpUserData,
-    editData, exportData,
+    editData, editModel, exportData,
     getModel, getResource,
     handleCustomEndpointRequest,
-    handleDemoInitialization, importData, insertData, installPack,
+    handleDemoInitialization, importData, insertData, installPack, loadFromDump,
     patchData, searchData, validateModelStructure
 } from "./data.js";
 import process from "node:process";

package/src/modules/mongodb.js

@@ -1,10 +1,12 @@
 
-import process from "process";
 import {Logger} from "../gameObject.js";
 import {MongoDatabase} from "../engine.js";
+import {ObjectId} from "mongodb";
 
 export let modelsCollection, datasCollection, filesCollection, packsCollection;
 
+export {ObjectId};
+
 let engine, logger;
 export async function onInit(defaultEngine) {
     engine = defaultEngine;

package/src/modules/workflow.js

@@ -6,7 +6,7 @@ import crypto from "node:crypto";
 import ivm from 'isolated-vm';
 
 import {Logger} from "../gameObject.js";
-import {deleteData, insertData, patchData, scheduleAlerts, searchData} from "./data/index.js";
+import {deleteData, getModel, insertData, patchData, scheduleAlerts, searchData} from "./data/index.js";
 import {emailDefaultConfig, maxExecutionsByStep, maxWorkflowSteps} from "../constants.js";
 import {ChatOpenAI} from "@langchain/openai";
 import {ChatGoogleGenerativeAI} from "@langchain/google-genai";
@@ -17,6 +17,8 @@ import {sendEmail} from "../email.js";
 
 import * as workflowModule from './workflow.js';
 import util from "node:util";
+import {object_equals} from "../core.js";
+import {isConditionMet} from "../filter.js";
 
 let logger = null;
 export async function onInit(defaultEngine) {
@@ -219,12 +221,18 @@ export async function executeSafeJavascript(actionDef, context, user) {
         };
 
         // 1. Build the sandboxed API
-        await jail.set('_db_create', new ivm.Reference((modelName, dataObject) => insertData(modelName, JSON.parse(dataObject), {}, user, false)));
+        await jail.set('_db_create', new ivm.Reference(async (modelName, dataObject) => {
+            const result = await insertData(modelName, JSON.parse(dataObject), {}, user, false);
+            if (result.success && result.insertedIds) {
+                result.insertedIds = result.insertedIds.map(id => id.toString());
+            }
+            return new ivm.ExternalCopy(result).copyInto();
+        }));
         await jail.set('_db_find', new ivm.Reference(find));
         await jail.set('_db_findOne', new ivm.Reference(findOne));
 
-        await jail.set('_db_update', new ivm.Reference((modelName, filter, updateObject) => patchData(modelName, JSON.parse(filter), JSON.parse(updateObject), {}, user, false)));
-        await jail.set('_db_delete', new ivm.Reference((modelName, filter) => deleteData(modelName, JSON.parse(filter), user, false)));
+        await jail.set('_db_update', new ivm.Reference(async (modelName, filter, updateObject) => patchData(modelName, JSON.parse(filter), JSON.parse(updateObject), {}, user, false)));
+        await jail.set('_db_delete', new ivm.Reference(async (modelName, filter) => deleteData(modelName, JSON.parse(filter), user, false)));
 
         const createLoggerMethod = (level) => {
             return (...args) => {
@@ -1099,102 +1107,96 @@ export async function substituteVariables(template, contextData, user) {
 }
 
 /**
- * Déclenche l'instanciation d'un workflowRun si les conditions sont remplies.
- * Vérifie le type d'événement et le filtre de données du déclencheur.
- * Crée un document 'workflowRun' pour une exécution asynchrone ultérieure.
+ * Triggers the instantiation of a workflowRun if conditions are met.
+ * Checks the event type and trigger's data filter.
+ * Creates a 'workflowRun' document for later asynchronous execution.
  *
- * @param {object} triggerData - La donnée qui a déclenché le(s) workflow(s) (peut être un document de données ou un document de modèle).
- * @param {object} user - L'utilisateur associé.
- * @param {'DataAdded' | 'DataEdited' | 'DataDeleted' | 'ModelAdded' | 'ModelEdited' | 'ModelDeleted'} eventType - Le type d'événement.
+ * @param {object} triggerData - The data that triggered the workflow(s) (can be a data document or model document).
+ * @param {object} user - The associated user.
+ * @param {'DataAdded' | 'DataEdited' | 'DataDeleted' | 'ModelAdded' | 'ModelEdited' | 'ModelDeleted'} eventType - The event type.
  */
-export async function triggerWorkflows(triggerData, user, eventType)  {
-    const dataId = eventType.startsWith('Model') ? null : triggerData._id;
-
+export async function triggerWorkflows(triggerData, user, eventType) {
     const trigger = async (triggerData, user, eventType) => {
-
         // Basic validation
         if (!triggerData || !user || !eventType) {
-            console.warn("triggerWorkflows: Appel invalide - triggerData, user, ou eventType manquant.", { hasTriggerData: !!triggerData, hasUser: !!user, eventType });
+            console.warn("triggerWorkflows: Invalid call - missing triggerData, user, or eventType.", {
+                hasTriggerData: !!triggerData,
+                hasUser: !!user,
+                eventType
+            });
             return;
         }
-        // Determine the model name and data ID based on the event type
+
+        // Determine model name and data ID based on event type
         const targetModelName = eventType.startsWith('Model') ? triggerData.name : triggerData._model;
-        const dataId = eventType.startsWith('Model') ? null : triggerData._id; // ID only relevant for data events
+        const dataId = eventType.startsWith('Model') ? null : triggerData._id;
 
         if (!targetModelName) {
-            console.warn(`triggerWorkflows: Impossible de déterminer le nom du modèle pour l'événement ${eventType}.`, triggerData);
+            console.warn(`triggerWorkflows: Cannot determine model name for event ${eventType}.`, triggerData);
             return;
         }
 
         console.log(`[Workflow Trigger] Event: ${eventType}, Model: ${targetModelName}${dataId ? `, Data ID: ${dataId}` : ''}, User: ${user.username}`);
 
         try {
-            const dbCollection = await getCollectionForUser(user); // Collection des données utilisateur
+            const dbCollection = await getCollectionForUser(user);
 
-            // 1. Trouver les WorkflowTriggers pertinents
+            // 1. Find relevant WorkflowTriggers
             const workflowTriggers = await dbCollection.find({
                 _model: 'workflowTrigger',
                 targetModel: targetModelName,
                 isActive: true,
-                onEvent: eventType, // Assurez-vous que le champ s'appelle bien 'onEvent' dans votre modèle
+                onEvent: eventType,
                 $or: [{_user: user._user}, {_user: user.username}]
             }).toArray();
 
             if (workflowTriggers.length === 0) {
-                console.debug(`[Workflow Trigger] Aucun déclencheur actif trouvé pour ${targetModelName} / ${eventType}.`);
+                console.debug(`[Workflow Trigger] No active triggers found for ${targetModelName}/${eventType}.`);
                 return;
             }
-            console.debug(`[Workflow Trigger] Trouvé ${workflowTriggers.length} déclencheur(s) potentiel(s) pour ${targetModelName} / ${eventType}.`);
+            console.debug(`[Workflow Trigger] Found ${workflowTriggers.length} potential trigger(s) for ${targetModelName}/${eventType}.`);
 
-            // 2. Pour chaque déclencheur trouvé, vérifier le filtre de données et créer un workflowRun
+            // 2. For each trigger, verify data filter and create workflowRun
             for (const trigger of workflowTriggers) {
-                console.debug(`[Workflow Trigger] Vérification du déclencheur ${trigger._id} (${trigger.name || 'Sans nom'})...`);
+                console.debug(`[Workflow Trigger] Evaluating trigger ${trigger._id} (${trigger.name || 'Unnamed'})...`);
 
-                // 3. Vérifier le filtre de données (dataFilter) si applicable
-                if (eventType.startsWith('Data') && trigger.dataFilter && dataId) {
+                // 3. Check data filter if applicable
+                if (eventType.startsWith('Data') && trigger.dataFilter) {
                     let dataFilterCondition = null;
                     try {
-                        // dataFilter est supposé être stocké comme un objet (ou une string JSON valide)
+                        // dataFilter is expected to be stored as an object or valid JSON string
                         if (typeof trigger.dataFilter === 'string') {
                             dataFilterCondition = JSON.parse(trigger.dataFilter);
                         } else if (typeof trigger.dataFilter === 'object' && trigger.dataFilter !== null) {
                             dataFilterCondition = trigger.dataFilter;
                         }
                     } catch (parseError) {
-                        console.error(`[Workflow Trigger] Erreur de parsing JSON pour dataFilter du trigger ${trigger._id}:`, parseError);
-                        continue; // Passer au trigger suivant si le filtre est invalide
+                        console.error(`[Workflow Trigger] JSON parsing error for dataFilter in trigger ${trigger._id}:`, parseError);
+                        continue; // Skip to next trigger if filter is invalid
                     }
 
                     try {
-                        const finalFilter = {
-                            '$and': [
-                                {"_id": { "$toObjectId": triggerData._id.toString() }},
-                                dataFilterCondition                      // Applique la condition du trigger
-                            ]
-                        };
-
-
-                        console.debug(`[Workflow Trigger] Vérification dataFilter pour trigger ${trigger._id} avec filtre combiné:`, JSON.stringify(finalFilter));
-                        const match = await searchData({ model: triggerData._model, filter: finalFilter, limit: 1 }, user);
-                        if (!match.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}.`);
+                        const mod = await getModel(targetModelName, user);
+                        const filterMatches = isConditionMet(mod, dataFilterCondition, triggerData, [], user);
+
+                        if (!filterMatches) {
+                            console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter not satisfied by data. Skipping workflowRun creation.`);
+                            continue;
                         }
+                        console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter satisfied.`);
                     } 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
+                        console.error(`[Workflow Trigger] Error evaluating dataFilter for trigger ${trigger._id}:`, filterError);
+                        continue;
                     }
-                } // Fin de la vérification dataFilter
+                }
 
-                // 4. Si les filtres (eventType, dataFilter) sont passés, créer l'instance workflowRun
+                // 4. If filters passed, create workflowRun instance
                 if (!trigger.workflow || !isObjectId(trigger.workflow)) {
-                    console.warn(`[Workflow Trigger] Trigger ${trigger._id} n'a pas de workflow valide associé.`);
+                    console.warn(`[Workflow Trigger] Trigger ${trigger._id} has no valid associated workflow.`);
                     continue;
                 }
 
-                // a. Récupérer la définition du Workflow (juste pour vérifier qu'il existe)
+                // a. Verify workflow exists
                 const workflowDefinition = await dbCollection.findOne({
                     _id: new ObjectId(trigger.workflow),
                     _model: 'workflow',
@@ -1202,21 +1204,20 @@ export async function triggerWorkflows(triggerData, user, eventType)  {
                 });
 
                 if (!workflowDefinition) {
-                    console.warn(`[Workflow Trigger] Workflow ${trigger.workflow} associé au trigger ${trigger._id} non trouvé.`);
+                    console.warn(`[Workflow Trigger] Workflow ${trigger.workflow} associated with trigger ${trigger._id} not found.`);
                     continue;
                 }
 
-                // b. Créer le document workflowRun
+                // b. Create workflowRun document
                 const workflowRunData = {
                     _model: 'workflowRun',
                     _user: user._user || user.username,
-                    workflow: workflowDefinition._id, // Référence au workflow parent
-                    contextData: {                        // Contexte initial
-                        triggerDataModel: targetModelName,// Modèle de la donnée déclencheuse
-                        triggerData: triggerData      // Inclure la donnée déclencheuse
-                        // Vous pourriez ajouter d'autres infos ici si nécessaire
+                    workflow: workflowDefinition._id,
+                    contextData: {
+                        triggerDataModel: targetModelName,
+                        triggerData: triggerData
                     },
-                    status: 'pending',                // Statut initial
+                    status: 'pending',
                     owner: null,
                     startedAt: new Date()
                 };
@@ -1224,30 +1225,25 @@ export async function triggerWorkflows(triggerData, user, eventType)  {
                 try {
                     const insertResult = await dbCollection.insertOne(workflowRunData);
                     if (insertResult.insertedId) {
-                        console.info(`[Workflow Trigger] WorkflowRun ${insertResult.insertedId} créé pour le workflow ${workflowDefinition.name} (ID: ${workflowDefinition._id}) déclenché par ${trigger._id}.`);
-
+                        console.info(`[Workflow Trigger] Created workflowRun ${insertResult.insertedId} for workflow ${workflowDefinition.name} (ID: ${workflowDefinition._id}) triggered by ${trigger._id}.`);
                         await workflowModule.processWorkflowRun(insertResult.insertedId, user);
                     } else {
-                        console.error(`[Workflow Trigger] Échec de la création du WorkflowRun pour le workflow ${workflowDefinition._id} (Trigger: ${trigger._id}).`);
+                        console.error(`[Workflow Trigger] Failed to create workflowRun for workflow ${workflowDefinition._id} (Trigger: ${trigger._id}).`);
                     }
                 } catch (insertError) {
-                    console.error(`[Workflow Trigger] Erreur lors de l'insertion du WorkflowRun pour le workflow ${workflowDefinition._id} (Trigger: ${trigger._id}):`, insertError);
+                    console.error(`[Workflow Trigger] Error creating workflowRun for workflow ${workflowDefinition._id} (Trigger: ${trigger._id}):`, insertError);
                 }
-
-            } // Fin de la boucle des triggers
-
+            }
         } catch (error) {
-            console.error(`[Workflow Trigger] Erreur générale dans triggerWorkflows pour ${targetModelName}${dataId ? ` ID: ${dataId}` : ''} (Event: ${eventType}):`, error);
+            console.error(`[Workflow Trigger] General error in triggerWorkflows for ${targetModelName}${dataId ? ` ID: ${dataId}` : ''} (Event: ${eventType}):`, error);
         }
     }
 
     return new Promise((resolve) => setTimeout(async () => {
         await trigger(triggerData, user, eventType);
         resolve();
-    }, 0)
-    );
+    }, 0));
 }
-
 /**
  * Processes a workflowRun instance step-by-step.
  * Fetches the run, evaluates conditions, executes actions, and transitions

package/test/data.integration.test.js

@@ -795,7 +795,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
                     name: 'produit',
                     type: 'relation',
                     relation: 'produitTestFiltre',
-                    relationFilter: { actif: true } // Only link active products
+                    relationFilter: { "$eq":["$actif", true] } // Only link active products
                 }
             ]
         };