data-primals-engine 1.2.2 → 1.2.3

package/client/src/DataEditor.jsx

@@ -25,6 +25,7 @@ import Draggable from "./Draggable.jsx";
 import CronBuilder from "./CronBuilder.jsx";
 import RTETrans from "./RTETrans.jsx";
 import uniqid from "uniqid";
+import {isConditionMet} from "data-primals-engine/filter";
 
 // ... (fonction getInputType) ...
 // Fonction pour obtenir le type d'input HTML basé sur le type de champ du modèle
@@ -52,208 +53,6 @@ const getInputType = (fieldType) => {
     }
 };
 
-/**
- * Evaluates a single condition against form data.
- * @param {object} currentModelDef - The definition of the current model.
- * @param {object} condition - The condition to evaluate.
- * @param {object} formData - The form data.
- * @param {object[]} allModels - An array of all model definitions.
- * @param {object} user - The current user.
- * @returns {boolean} - True if the condition is met, false otherwise.
- */
-const evaluateSingleCondition = (currentModelDef, condition, formData, allModels, user) => {
-    // Condition est directement un filtre MongoDB, donc on l'applique
-    // en utilisant les opérateurs et les valeurs qu'il contient.
-
-    if (!condition || typeof condition !== 'object') {
-        console.warn("[Client Eval] Condition is not an object:", condition);
-        return true; // Permissive default
-    }
-
-    // Si la condition contient des opérateurs logiques, on les gère ici
-    if (condition.$and || condition.$or || condition.$not || condition.$nor) {
-        console.warn("[Client Eval] Condition logique détectée dans evaluateSingleCondition, ce n'est pas attendu. Devrait être géré par isConditionMet.");
-        return true; // Permissive default
-    }
-
-    if (condition.$find) {
-        const fieldName = Object.keys(condition)[0];
-        const fieldValue = formData[fieldName];
-        const findCondition = condition.$find;
-
-        if (!Array.isArray(fieldValue)) return false;
-
-        return fieldValue.some(item => {
-            // Gestion spéciale pour la syntaxe $eq: ["$$this.field", value]
-            if (findCondition.$eq && Array.isArray(findCondition.$eq)) {
-                const [fieldPath, value] = findCondition.$eq;
-                if (fieldPath.startsWith("$$this.")) {
-                    const fieldToCheck = fieldPath.replace("$$this.", "");
-                    return item[fieldToCheck] == value;
-                }
-            }
-
-            // Sinon, évaluation normale
-            const tempData = { ...item };
-            return evaluateSingleCondition(currentModelDef, findCondition, tempData, allModels, user);
-        });
-    }
-
-    // Si la condition contient un opérateur $exists, on le gère ici
-    if (condition.$exists !== undefined) {
-        const fieldName = Object.keys(condition)[0]; // Récupérer le nom du champ
-        const shouldExist = condition.$exists; // Récupérer la valeur de $exists (true ou false)
-        const exists = Object.prototype.hasOwnProperty.call(formData, fieldName) && formData[fieldName] !== undefined && formData[fieldName] !== null;
-        return exists === shouldExist;
-    }
-
-    // Si la condition contient un opérateur $find, on le gère ici
-    if (condition.$find) {
-        // Récupérer le nom du champ
-        const fieldName = Object.keys(condition)[0];
-        const fieldValue = formData[fieldName];
-        try {
-            // Assuming evaluateSingleCondition handles $find
-            return evaluateSingleCondition(currentModelDef, condition.$find, formData, allModels, user);
-        } catch (error) {
-            console.error("Error evaluating $find condition:", condition, error);
-            return false;
-        }
-    }
-
-    // Récupérer le nom du champ et la condition
-    const fieldName = Object.keys(condition)[0];
-    const fieldValue = condition[fieldName];
-
-    // Récupérer la définition du champ
-    const fieldDef = currentModelDef?.fields.find(f => f.name === fieldName);
-
-    // Si la définition du champ n'est pas trouvée, on retourne true
-    if (!fieldDef) {
-        console.warn(`[Client Eval] Field definition not found for field: ${fieldName}`);
-        return true; // Permissive default
-    }
-
-    let targetValue = formData[fieldName];
-    let processedConditionValue = fieldValue;
-
-    // 1. Handle $exists (on the first field)
-    // 2. Convert condition value based on operator's expected input type
-    const fieldType = fieldDef?.type; // Type of the first field
-
-    try {
-        processedConditionValue = convertValueType(fieldValue, fieldType);
-    } catch (e) {
-        logClientEvalWarning(`Error converting value type: ${e.message}`, condition);
-        return false;
-    }
-
-    return evaluateComparison(fieldValue, targetValue, processedConditionValue, condition);
-
-    function logClientEvalWarning(message, details) {
-        console.warn(`[Client Eval] ${message}:`, details);
-    }
-
-    function convertValueType(value, inputType) {
-        switch (inputType) {
-            case 'number':
-                const numValue = parseFloat(value);
-                if (isNaN(numValue)) {
-                    throw new Error(`Invalid number value: ${value}`);
-                }
-                return numValue;
-            case 'boolean':
-                return String(value).toLowerCase() === 'true';
-            case 'csv':
-                return String(value).split(',').map(item => item.trim()).filter(Boolean);
-            case 'text':
-            default:
-                return String(value);
-        }
-    }
-
-    function evaluateComparison(operator, targetValue, processedConditionValue, condition) {
-        try {
-            switch (typeof operator === 'object' ? Object.keys(operator)[0] : null) {
-                case '$eq': return targetValue == processedConditionValue;
-                case '$ne': return targetValue != processedConditionValue;
-                case '$gt': return targetValue > processedConditionValue;
-                case '$lt': return targetValue < processedConditionValue;
-                case '$gte': return targetValue >= processedConditionValue;
-                case '$lte': return targetValue <= processedConditionValue;
-                case '$regex':
-                    if (typeof targetValue !== 'string') return false;
-                    if (typeof processedConditionValue !== 'string') return false;
-                    try {
-                        const regex = new RegExp(processedConditionValue, 'i');
-                        return regex.test(targetValue);
-                    } catch (e) {
-                        logClientEvalWarning(`Invalid regex pattern: ${processedConditionValue}`, condition);
-                        return false;
-                    }
-                case '$in':
-                    return Array.isArray(processedConditionValue) && processedConditionValue.includes(String(targetValue));
-                case '$nin':
-                    return !Array.isArray(processedConditionValue) || !processedConditionValue.includes(String(targetValue));
-                default:
-                    logClientEvalWarning(`Unhandled operator in client evaluation logic: ${operator}`, condition);
-                    return true; // Permissive default
-            }
-        } catch (evalError) {
-            logClientEvalWarning(`Error during client condition evaluation: ${operator}, targetValue=${targetValue}, processedConditionValue=${processedConditionValue}`, condition);
-            return false;
-        }
-    }
-};
-
-export const isConditionMet = (model, cond, formData, allModels, user) => {
-    const isNode = (v) => typeof v === 'object' && v !== null;
-
-    const condition = cond;
-
-    if (!condition) return true;
-
-    if (condition.$and && Array.isArray(condition.$and)) {
-        if (condition.$and.length === 0) return true;
-        return condition.$and.every(sub => isConditionMet(model, sub, formData, allModels, user));
-    }
-
-    if (condition.$or && Array.isArray(condition.$or)) {
-        if (condition.$or.length === 0) return false;
-        return condition.$or.some(sub => isConditionMet(model, sub, formData, allModels, user));
-    }
-
-    if (condition.$not) {
-        return !isConditionMet(model, condition.$not, formData, allModels, user);
-    }
-
-    if (condition.$nor && Array.isArray(condition.$nor)) {
-        if (condition.$nor.length === 0) return true;
-        return !condition.$nor.some(sub => isConditionMet(model, sub, formData, allModels, user));
-    }
-
-    if (condition.$find) {
-        try {
-            // Assuming evaluateSingleCondition handles $find
-            return evaluateSingleCondition(model, condition, formData, allModels, user);
-        } catch (error) {
-            console.error("Error evaluating $find condition:", condition, error);
-            return false;
-        }
-    }
-
-    if (condition.path && condition.op) {
-        try {
-            return evaluateSingleCondition(model, condition, formData, allModels, user);
-        } catch (error) {
-            console.error("Error evaluating condition:", condition, error);
-            return false;
-        }
-    }
-
-    console.warn("Unknown condition format:", condition);
-    return true;
-};
 
 export const DataEditor = forwardRef(function MyDataEditor({
    isLoading,

package/client/src/DataTable.jsx

@@ -43,7 +43,6 @@ import RelationValue from "./RelationValue.jsx";
 import {FaGear, FaPencil, FaTriangleExclamation} from "react-icons/fa6";
 import RestoreConfirmationModal from "./RestoreConfirmationModal.jsx";
 import {event_trigger, isLightColor} from "../../src/core.js";
-import {isConditionMet} from "./DataEditor.jsx";
 import {Tooltip} from "react-tooltip";
 import ExportDialog from "./ExportDialog.jsx";
 import Captions from "yet-another-react-lightbox/plugins/captions";
@@ -58,6 +57,7 @@ import PackGallery from "./PackGallery.jsx";
 import {HiddenableCell} from "./HiddenableCell.jsx";
 import ConditionBuilder from "./ConditionBuilder.jsx";
 import {pagedFilterToMongoConds} from "./filter.js";
+import {isConditionMet} from "data-primals-engine/filter";
 
 // Ajoutez cette constante pour la clé de sessionStorage
 const SESSION_STORAGE_IMPORT_JOBS_KEY = 'activeImportJobs';

package/client/src/constants.js

@@ -53,7 +53,7 @@ export const MONGO_OPERATORS = {
 export const profiles = {
     'personal': ['contact', 'location', 'imageGallery', 'budget', 'currency', 'taxonomy'], // budget,
     'developer': ['alert','endpoint','request','webpage', 'content', 'taxonomy', 'resource', 'translation', 'contact', 'location', 'channel', 'lang', 'token', 'message', 'ticket', 'user', 'permission', 'role'],
-    'company': ['alert','request','location', 'campaign', 'order', 'currency', 'product', 'cart', 'cartItem', 'invoice', 'message', 'user', 'role', 'permission', 'token','translation', 'lang', 'webpage', 'content', 'taxonomy', 'contact', 'resource', 'accountingExercise', 'accountingLineItem', 'accountingEntry', 'employee', 'kpi', 'dashboard'],
+    'company': ['alert','request','location', 'order', 'currency', 'product', 'cart', 'cartItem', 'invoice', 'message', 'user', 'role', 'permission', 'token','translation', 'lang', 'webpage', 'content', 'taxonomy', 'contact', 'resource', 'accountingExercise', 'accountingLineItem', 'accountingEntry', 'employee', 'kpi', 'dashboard'],
     'engineer': ['alert','endpoint','request','dashboard', 'kpi', 'user', 'role', 'token', 'permission', 'workflow', 'workflowRun', 'workflowStep', "channel", "message", 'workflowAction', 'workflowTrigger']
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-primals-engine",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "data-primals-engine is a package responsible from handling large amount of data using MongoDB in a practical and performant way. It can also get workflow models working (for automation), and fully supports internationalisation. It also has integrated AI assistant.",
   "main": "src/engine.js",
   "type": "module",

package/src/constants.js

@@ -66,7 +66,7 @@ export const awsDefaultConfig = {
 export const emailDefaultConfig = {
     from: "Support - data@primals.net <data@primals.net>",
     host: 'smtp.mydomain.tld',
-    port: 2500,
+    port: 587,
     secure: false,
     user: 'user',
     pass: 'password'
@@ -288,7 +288,7 @@ metaModels['messaging'] = { load: ['alert','ticket', 'message', 'channel'], 'req
 metaModels['eshopping'] = { load: [
     'order', 'currency', 'product', 'productVariant', 'discount', 'cart', 'cartItem',
     'brand', 'return', 'review', 'stock', 'returnItem', 'userSubscription',
-    'warehouse', 'shipment', 'campaign', 'stockAlert', 'invoice'],
+    'warehouse', 'shipment', 'stockAlert', 'invoice'],
 'require': ['i18n', 'users', 'messaging'] };
 metaModels['workflow'] = { load: ['env', 'workflow', 'workflowRun', 'workflowAction', 'workflowStep', 'workflowTrigger']};
 metaModels['erp'] = { load: [ 'accountingExercise', 'accountingLineItem', 'accountingEntry', 'employee', 'dashboard', 'kpi'] };

package/src/defaultModels.js

@@ -543,19 +543,6 @@ export const defaultModels = {
             { name: 'createdAt', type: 'datetime', required: true }
         ]
     },
-    campaign: {
-        name: 'campaign',
-        "description": "",
-        fields: [
-            { name: 'name', type: 'string_t', required: true },
-            { name: 'description', type: 'richtext' },
-            { name: 'startDate', type: 'datetime' },
-            { name: 'endDate', type: 'datetime' },
-            { name: 'type', type: 'enum', items: ['email', 'sms', 'advertisement', 'promotion'] },
-            { name: 'status', type: 'enum', items: ['planified', 'in_progress', 'finished', 'cancelled'] },
-            { name: 'budget', type: 'number' }
-        ]
-    },
     review: {
         name: "review",
         "description": "",
@@ -1014,7 +1001,7 @@ export const defaultModels = {
             { name: 'owner', type: 'relation', relation: 'user', required: false },
             { name: 'startedAt', type: 'datetime', required: true, hint: "Timestamp when the workflow run began." },
             { name: 'completedAt', type: 'datetime', hint: "Timestamp when the workflow run finished (successfully or failed)." },
-            { name: 'error', type: 'string', maxlength: 4096, hint: "Error message if the workflow run failed." }
+            { name: 'log', type: 'string', maxlength: 4096, hint: "Error message if the workflow run failed." }
         ]
     },
     dashboard:{

package/src/email.js

@@ -6,12 +6,12 @@ import {emailDefaultConfig} from "./constants.js";
 
 // Le transporteur par défaut, utilisé si aucune config spécifique n'est fournie.
 const defaultTransporter = nodemailer.createTransport({
-    host: "mail.smtp2go.com",
-    port: 587,
+    host: process.env.SMTP_HOST,
+    port: process.env.SMTP_PORT || 587,
     secure: false,
     auth: {
-        user: process.env.MAIL_USER,
-        pass: process.env.MAIL_PASS
+        user: process.env.SMTP_USER,
+        pass: process.env.SMTP_PASS
     }
 });
 
@@ -52,7 +52,9 @@ export const sendEmail = async (email = "", data, smtpConfig = null, lang, tpl =
     // Choisir le transporteur à utiliser
     const transporter = smtpConfig ? createTransporter(smtpConfig||emailDefaultConfig) : defaultTransporter;
 
-    if (tpl === null) tpl = Event.Trigger("sendEmail:template", "system", "calls", data, lang);
+    Event.Listen("OnEmailTemplate", (data, lang) => data.content, "event", "system");
+
+    if (tpl === null) tpl = Event.Trigger("OnEmailTemplate", "event", "system", data, lang);
     let html = tpl;
     try {
         html = juice(tpl);

package/src/engine.js

@@ -13,7 +13,7 @@ import {
 import http from "http";
 import cookieParser from "cookie-parser";
 import requestIp from 'request-ip';
-import {createModel, deleteModels, getModels, validateModelStructure} from "./modules/data.js";
+import {createModel, deleteModels, getModels, installAllPacks, validateModelStructure} from "./modules/data.js";
 import {defaultModels} from "./defaultModels.js";
 import {DefaultUserProvider} from "./providers.js";
 import formidableMiddleware from 'express-formidable';
@@ -175,6 +175,7 @@ export const Engine = {
             server.listen(port);
 
             await setupInitialModels();
+            await installAllPacks();
 
             if (cb)
                 await cb();

package/src/events.js

@@ -60,7 +60,7 @@ export const Event = {
         }
         return ret;
     },
-    Listen: (name = "", callback = () => {}, system = "priority", layer = "medium") => {
+    Listen: (name = "", callback, system = "priority", layer = "medium") => {
         const validSystems = Object.keys(eventLayerSystems); // Récupération des clés pour une vérification plus performante
         if (!validSystems.includes(system)) {
             throw new Error(`System '${system}' does not exist. Valid systems are: ${validSystems.join(', ')}`); // Message d'erreur plus informatif

package/src/filter.js

@@ -0,0 +1,221 @@
+/**
+ * Evaluates a single condition against form data.
+ * @param {object} currentModelDef - The definition of the current model.
+ * @param {object} condition - The condition to evaluate.
+ * @param {object} formData - The form data.
+ * @param {object[]} allModels - An array of all model definitions.
+ * @param {object} user - The current user.
+ * @returns {boolean} - True if the condition is met, false otherwise.
+ */
+const evaluateSingleCondition = (currentModelDef, condition, formData, allModels, user) => {
+    // Condition est directement un filtre MongoDB, donc on l'applique
+    // en utilisant les opérateurs et les valeurs qu'il contient.
+
+    if (!condition || typeof condition !== 'object') {
+        console.warn("[Client Eval] Condition is not an object:", condition);
+        return true; // Permissive default
+    }
+
+    // Si la condition est de la forme {field: value}, on la transforme en {$eq: value}
+    if (!Object.keys(condition)[0].startsWith('$') && typeof condition[Object.keys(condition)[0]] !== 'object') {
+        const fieldName = Object.keys(condition)[0];
+        const value = condition[fieldName];
+        return evaluateSingleCondition(currentModelDef, {[fieldName]: {$eq: value}}, formData, allModels, user);
+    }
+
+    // Gestion des opérateurs d'agrégation (commencent par $)
+    const operator = Object.keys(condition)[0];
+    if (operator === '$eq' && Array.isArray(condition[operator])) {
+        // Cas spécial pour {$eq: ['$field', value]}
+        const [fieldPath, expectedValue] = condition[operator];
+        if (typeof fieldPath === 'string' && fieldPath.startsWith('$')) {
+            const fieldName = fieldPath.substring(1); // Enlève le $ devant
+            return formData[fieldName] == expectedValue;
+        }
+    }
+
+    // Si la condition contient des opérateurs logiques, on les gère ici
+    if (condition.$and || condition.$or || condition.$not || condition.$nor) {
+        console.warn("[Client Eval] Condition logique détectée dans evaluateSingleCondition, ce n'est pas attendu. Devrait être géré par isConditionMet.");
+        return true; // Permissive default
+    }
+
+    if (condition.$find) {
+        const fieldName = Object.keys(condition)[0];
+        const fieldValue = formData[fieldName];
+        const findCondition = condition.$find;
+
+        if (!Array.isArray(fieldValue)) return false;
+
+        return fieldValue.some(item => {
+            // Gestion spéciale pour la syntaxe $eq: ["$$this.field", value]
+            if (findCondition.$eq && Array.isArray(findCondition.$eq)) {
+                const [fieldPath, value] = findCondition.$eq;
+                if (fieldPath.startsWith("$$this.")) {
+                    const fieldToCheck = fieldPath.replace("$$this.", "");
+                    return item[fieldToCheck] == value;
+                }
+            }
+
+            // Sinon, évaluation normale
+            const tempData = { ...item };
+            return evaluateSingleCondition(currentModelDef, findCondition, tempData, allModels, user);
+        });
+    }
+
+    // Si la condition contient un opérateur $exists, on le gère ici
+    if (condition.$exists !== undefined) {
+        const fieldName = Object.keys(condition)[0]; // Récupérer le nom du champ
+        const shouldExist = condition.$exists; // Récupérer la valeur de $exists (true ou false)
+        const exists = Object.prototype.hasOwnProperty.call(formData, fieldName) && formData[fieldName] !== undefined && formData[fieldName] !== null;
+        return exists === shouldExist;
+    }
+
+    // Si la condition contient un opérateur $find, on le gère ici
+    if (condition.$find) {
+        // Récupérer le nom du champ
+        const fieldName = Object.keys(condition)[0];
+        const fieldValue = formData[fieldName];
+        try {
+            // Assuming evaluateSingleCondition handles $find
+            return evaluateSingleCondition(currentModelDef, condition.$find, formData, allModels, user);
+        } catch (error) {
+            console.error("Error evaluating $find condition:", condition, error);
+            return false;
+        }
+    }
+
+    // Récupérer le nom du champ et la condition
+    const fieldName = Object.keys(condition)[0];
+    const fieldValue = condition[fieldName];
+
+    // Récupérer la définition du champ
+    const fieldDef = currentModelDef?.fields.find(f => f.name === fieldName);
+
+    // Si la définition du champ n'est pas trouvée, on retourne true
+    if (!fieldDef) {
+        console.warn(`[Client Eval] Field definition not found for field: ${fieldName}`);
+        return true; // Permissive default
+    }
+
+    let targetValue = formData[fieldName];
+    let processedConditionValue = fieldValue;
+
+    // 1. Handle $exists (on the first field)
+    // 2. Convert condition value based on operator's expected input type
+    const fieldType = fieldDef?.type; // Type of the first field
+
+    try {
+        processedConditionValue = convertValueType(fieldValue, fieldType);
+    } catch (e) {
+        logClientEvalWarning(`Error converting value type: ${e.message}`, condition);
+        return false;
+    }
+
+    return evaluateComparison(fieldValue, targetValue, processedConditionValue, condition);
+
+    function logClientEvalWarning(message, details) {
+        console.warn(`[Client Eval] ${message}:`, details);
+    }
+
+    function convertValueType(value, inputType) {
+        switch (inputType) {
+        case 'number':
+            const numValue = parseFloat(value);
+            if (isNaN(numValue)) {
+                throw new Error(`Invalid number value: ${value}`);
+            }
+            return numValue;
+        case 'boolean':
+            return String(value).toLowerCase() === 'true';
+        case 'csv':
+            return String(value).split(',').map(item => item.trim()).filter(Boolean);
+        case 'text':
+        default:
+            return String(value);
+        }
+    }
+
+    function evaluateComparison(operator, targetValue, processedConditionValue, condition) {
+        try {
+            switch (typeof operator === 'object' ? Object.keys(operator)[0] : null) {
+            case '$eq': return targetValue == processedConditionValue;
+            case '$ne': return targetValue != processedConditionValue;
+            case '$gt': return targetValue > processedConditionValue;
+            case '$lt': return targetValue < processedConditionValue;
+            case '$gte': return targetValue >= processedConditionValue;
+            case '$lte': return targetValue <= processedConditionValue;
+            case '$regex':
+                if (typeof targetValue !== 'string') return false;
+                if (typeof processedConditionValue !== 'string') return false;
+                try {
+                    const regex = new RegExp(processedConditionValue, 'i');
+                    return regex.test(targetValue);
+                } catch (e) {
+                    logClientEvalWarning(`Invalid regex pattern: ${processedConditionValue}`, condition);
+                    return false;
+                }
+            case '$in':
+                return Array.isArray(processedConditionValue) && processedConditionValue.includes(String(targetValue));
+            case '$nin':
+                return !Array.isArray(processedConditionValue) || !processedConditionValue.includes(String(targetValue));
+            default:
+                logClientEvalWarning(`Unhandled operator in client evaluation logic: ${operator}`, condition);
+                return true; // Permissive default
+            }
+        } catch (evalError) {
+            logClientEvalWarning(`Error during client condition evaluation: ${operator}, targetValue=${targetValue}, processedConditionValue=${processedConditionValue}`, condition);
+            return false;
+        }
+    }
+};
+
+export const isConditionMet = (model, cond, formData, allModels, user) => {
+    const condition = cond;
+
+    if (!condition) return true;
+
+    // Cas 1: Condition simple {field: value} → transformée en {field: {$eq: value}}
+    if (typeof condition === 'object' && !Array.isArray(condition)) {
+        const keys = Object.keys(condition);
+        if (keys.length === 1 && !keys[0].startsWith('$') &&
+            typeof condition[keys[0]] !== 'object') {
+            const simpleCondition = {
+                [keys[0]]: {$eq: condition[keys[0]]}
+            };
+            return evaluateSingleCondition(model, simpleCondition, formData, allModels, user);
+        }
+    }
+
+    // Cas 2: Opérateurs logiques ($and, $or, $not, $nor)
+    if (condition.$and && Array.isArray(condition.$and)) {
+        if (condition.$and.length === 0) return true;
+        return condition.$and.every(sub => isConditionMet(model, sub, formData, allModels, user));
+    }
+
+    if (condition.$or && Array.isArray(condition.$or)) {
+        if (condition.$or.length === 0) return false;
+        return condition.$or.some(sub => isConditionMet(model, sub, formData, allModels, user));
+    }
+
+    if (condition.$not) {
+        return !isConditionMet(model, condition.$not, formData, allModels, user);
+    }
+
+    if (condition.$nor && Array.isArray(condition.$nor)) {
+        if (condition.$nor.length === 0) return true;
+        return !condition.$nor.some(sub => isConditionMet(model, sub, formData, allModels, user));
+    }
+
+    // Cas 3: Syntaxe d'agrégation {$eq: ['$field', value]}
+    if (Object.keys(condition).length === 1) {
+        const operator = Object.keys(condition)[0];
+        if (operator.startsWith('$') && operator !== '$find' &&
+            Array.isArray(condition[operator])) {
+            return evaluateSingleCondition(model, condition, formData, allModels, user);
+        }
+    }
+
+    // Cas 4: Tous les autres cas (conditions normales avec opérateurs)
+    return evaluateSingleCondition(model, condition, formData, allModels, user);
+};

package/src/modules/data.js

@@ -47,14 +47,14 @@ import {
 } from "./mongodb.js";
 import {dbUrl, MongoClient, MongoDatabase} from "../engine.js";
 import path from "node:path";
-import {getFileExtension, getObjectHash, getRandom, isGUID, isPlainObject, randomDate, uuidv4} from "../core.js";
+import {getFileExtension, getObjectHash, getRandom, isGUID, isPlainObject, randomDate, sleep, uuidv4} from "../core.js";
 import {Event} from "../events.js";
 import fs from "node:fs";
 import schedule from "node-schedule";
 import {middleware} from "../middlewares/middleware-mongodb.js";
 import i18n from "../i18n.js";
 import {
-    executeSafeJavascript,
+    executeSafeJavascript, processWorkflowRun,
     runScheduledJobWithDbLock,
     scheduleWorkflowTriggers,
     triggerWorkflows
@@ -94,7 +94,6 @@ const sseConnections = new Map();
 const delay = ms => new Promise(res => setTimeout(res, ms));
 
 const getBackupDir = () => process.env.BACKUP_DIR || './backups'; // Répertoire de stockage des sauvegardes
-const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 
 let importJobs = {};
@@ -1386,6 +1385,7 @@ export async function onInit(defaultEngine) {
     schedule.scheduleJob("0 2 * * *", jobDumpUserData);
     //await jobDumpUserData();
 
+
     schedule.scheduleJob("0 0 * * *", async () => {
         const dt = new Date();
         dt.setTime(dt.getTime()-1000*3600*24*14);
@@ -1967,7 +1967,7 @@ export async function onInit(defaultEngine) {
             const filter = req.fields.filter;
             const hash = req.params.id; // Récupérer l'identifiant de la ressource à modifier
             const data = req.fields.data || (req.fields._data && JSON.parse(req.fields._data));
-            const r = await editData(req.fields.model, filter || hash, data, req.files, req.me)
+            const r = await editData(req.fields.model, filter || { "$eq": ["$_id", { "$toObjectId": hash}]}, data, req.files, req.me)
             if (r.error)
                 res.status(400).json(r);
             else
@@ -2889,14 +2889,14 @@ export const deleteModels = async (filter) => {
 }
 
 export const getModel = async (modelName, user) => {
-    const modelInCache = modelsCache.get(user.username+"@@"+modelName);
+    const modelInCache = modelsCache.get((user?.username||'')+"@@"+modelName);
     if(modelInCache)
         return modelInCache;
-    const model = await getCollection('models').findOne({name: modelName, $and: [{_user: {$exists: true}}, {$or: [{_user: user._user}, {_user: user.username}]}]});
+    const model = await getCollection('models').findOne({name: modelName, $and: user ? [{_user: {$exists: true}}, {$or: [{_user: user._user}, {_user: user.username}]}] : [{_user: { $exists: false}}]});
     if (!model) {
         throw new Error(i18n.t('api.model.notFound', {model: modelName}));
     }
-    modelsCache.set(user.username+"@@"+modelName, model);
+    modelsCache.set((user?.username||'')+"@@"+modelName, model);
     return model;
 }
 export const getModels = async ()  => {
@@ -4135,7 +4135,7 @@ export const deleteData = async (modelName, filter, user ={}, triggerWorkflow, w
 export const searchData = async (query, user) => {
     const { page, limit, sort, model, ids, timeout, pack } = query; // Les filtres de la requête (attention aux injections MongoDB !)
 
-    if( user.username !== 'demo' && isLocalUser(user) && (
+    if( user && user.username !== 'demo' && isLocalUser(user) && (
         !await hasPermission(["API_ADMIN", "API_SEARCH_DATA", "API_SEARCH_DATA_"+model], user) ||
         await hasPermission(["API_SEARCH_DATA_NOT_"+model], user))){
         throw new Error(i18n.t('api.permission.searchData'));
@@ -5988,4 +5988,4 @@ export async function handleDemoInitialization(req, res) {
         logger.error(`[Demo Init] Critical error during initialization for user '${user.username}':`, error);
         res.status(500).json({ success: false, error: 'An internal server error occurred during initialization.' });
     }
-}
+}