data-primals-engine 1.6.2 → 1.6.5

package/src/defaultModels.js

@@ -14,6 +14,14 @@ export const defaultModels = {
             {
                 "name": "description",
                 "type": "richtext"
+            },
+            {
+                "name": "filter",
+                "type": "code",
+                "language": "json",
+                "conditionBuilder": true,
+                "required": false,
+                "hint": "Filtre JSON qui restreint la portée de cette permission. Le modèle cible est déduit du nom de la permission (ex: 'product.edit')."
             }
         ]
     },
@@ -1111,6 +1119,12 @@ export const defaultModels = {
                 hint: "The current status of the workflow execution."
             },
             { name: 'stepExecutionsCount', type: 'object' },
+            {
+                name: 'history',
+                type: 'array',
+                itemsType: 'object',
+                hint: "Stores the detailed execution history of each step and action."
+            },
             { name: 'currentStep', type: 'relation', relation: 'workflowStep', hint: "The step currently being executed or waited on." },
             { name: 'owner', type: 'relation', relation: 'user', required: false },
             { name: 'startedAt', type: 'datetime', required: true, hint: "Timestamp when the workflow run began." },

package/src/filter.js

@@ -9,6 +9,83 @@ export function setSafeRegex(validator) {
     safeRegex = validator;
 }
 
+/**
+ * Évalue une comparaison entre une valeur cible et une valeur de condition.
+ * @param {string} operator - L'opérateur de comparaison (ex: '$eq', '$lt').
+ * @param {*} targetValue - La valeur actuelle du champ dans les données.
+ * @param {*} processedConditionValue - La valeur de la condition à comparer.
+ * @param {object} condition - La condition complète pour le contexte de logging.
+ * @returns {boolean} - Le résultat de la comparaison.
+ */
+function evaluateComparison(operator, targetValue, processedConditionValue, condition) {
+    const logClientEvalWarning = (message, details) => {
+        console.warn(`[Client Eval] ${message}:`, details);
+    };
+
+    try {
+        switch (operator) {
+            case '$eq': return targetValue == processedConditionValue; // Utilise '==' pour une comparaison plus souple
+            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' || !processedConditionValue || typeof processedConditionValue !== 'string') return false;
+                try {
+                    if (safeRegex && !safeRegex(processedConditionValue)) return false;
+                    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(targetValue);
+            case '$nin': return !Array.isArray(processedConditionValue) || !processedConditionValue.includes(targetValue);
+            default: return true; // Permissif par défaut pour les opérateurs non gérés
+        }
+    } catch (evalError) {
+        logClientEvalWarning(`Error during condition evaluation: ${operator}, targetValue=${targetValue}, processedConditionValue=${processedConditionValue}`, condition);
+        return false;
+    }
+}
+
+/**
+ * Récupère une valeur imbriquée dans un objet en utilisant une chaîne de chemin.
+ * Gère les tableaux et les objets. Retourne undefined si le chemin n'est pas trouvé.
+ * Exemple: getNestedValue({ a: { b: [ { c: 1 } ] } }, 'a.b.0.c') -> 1
+ *
+ * @param {object} obj L'objet source.
+ * @param {string} path La chaîne de chemin (ex: 'user.address.city').
+ * @returns {*} La valeur trouvée ou undefined.
+ */
+function getNestedValue(obj, path) {
+    // Vérifie si l'objet ou le chemin est invalide
+    if (!obj || typeof path !== 'string') {
+        return undefined;
+    }
+    // Sépare le chemin en clés individuelles (ex: 'a.b.0.c' -> ['a', 'b', '0', 'c'])
+    const keys = path.split('.');
+    let current = obj; // Commence à la racine de l'objet
+
+    // Parcourt chaque clé dans le chemin
+    for (const key of keys) {
+        // Si à un moment donné on atteint null ou undefined, le chemin est invalide
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        // Récupère la valeur pour la clé actuelle
+        const value = current[key];
+        // Si la valeur est undefined, le chemin est invalide
+        if (value === undefined) {
+            return undefined;
+        }
+        // Passe au niveau suivant de l'objet/tableau
+        current = value;
+    }
+    // Retourne la valeur finale trouvée
+    return current;
+}
 /**
  * Evaluates a single condition against form data.
  * @param {object} currentModelDef - The definition of the current model.
@@ -27,6 +104,17 @@ const evaluateSingleCondition = (currentModelDef, condition, formData, allModels
         return true; // Permissive default
     }
 
+    // If the condition is a standard query operator like { amount: { $lt: 1000 } }
+    const fieldNameFromCondition = Object.keys(condition)[0];
+    const conditionValueObject = condition[fieldNameFromCondition];
+
+    if (typeof conditionValueObject === 'object' && conditionValueObject !== null && !Array.isArray(conditionValueObject)) {
+        const operator = Object.keys(conditionValueObject)[0];
+        if (operator.startsWith('$')) {
+            return evaluateComparison(operator, formData[fieldNameFromCondition], conditionValueObject[operator], condition, checkRegex);
+        }
+    }
+
     // 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];
@@ -41,12 +129,12 @@ const evaluateSingleCondition = (currentModelDef, condition, formData, allModels
         const [fieldPath, expectedValue] = condition[operator];
         if (typeof fieldPath === 'string' && fieldPath.startsWith('$')) {
             const fieldName = fieldPath.substring(1); // Enlève le $ devant
-            const actualValue = formData[fieldName];
-            if (operator === '$eq') return actualValue == expectedValue;
-            if (operator === '$ne') return actualValue != expectedValue;
+            const actualValue = getNestedValue(formData, fieldName);
+            return evaluateComparison(operator, actualValue, expectedValue, condition, checkRegex);
         }
     }
 
+
     // 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.");
@@ -125,7 +213,7 @@ const evaluateSingleCondition = (currentModelDef, condition, formData, allModels
         return false;
     }
 
-    return evaluateComparison(fieldValue, targetValue, processedConditionValue, condition);
+    return evaluateComparison('$eq', targetValue, processedConditionValue, condition);
 
     function logClientEvalWarning(message, details) {
         console.warn(`[Client Eval] ${message}:`, details);
@@ -149,43 +237,6 @@ const evaluateSingleCondition = (currentModelDef, condition, formData, allModels
         }
     }
 
-    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 {
-                    // On vérifie si la fonction a été injectée ET si la regex est sûre.
-                    // Côté client, `safeRegex` sera null, donc la vérification est simplement ignorée.
-                    if( checkRegex && safeRegex && safeRegex(processedConditionValue)) {
-                        const regex = new RegExp(processedConditionValue, 'i');
-                        return regex.test(targetValue);
-                    }
-                    return false;
-                } 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,checkRegex=true) => {
@@ -197,6 +248,22 @@ export const isConditionMet = (model, cond, formData, allModels, user,checkRegex
         return true;
     }
 
+    // --- NOUVELLE LOGIQUE ---
+    // Gère les conditions de type expression d'agrégation comme { "$lt": ["$amount", 1000] }
+    const operatorKeys = Object.keys(condition).filter(k => k.startsWith('$'));
+    if (operatorKeys.length === 1) {
+        const operator = operatorKeys[0];
+        const operands = condition[operator];
+
+        if (Array.isArray(operands) && operands.length === 2 && typeof operands[0] === 'string' && operands[0].startsWith('$')) {
+            const fieldName = operands[0].substring(1); // Extrait 'amount' de '$amount'
+            const expectedValue = operands[1];
+            const actualValue = getNestedValue(formData, fieldName);
+
+            return evaluateComparison(operator, actualValue, expectedValue, condition, checkRegex);
+        }
+    }
+
     // Cas spécial: Évaluation sans modèle (ex: pour les webhooks où la condition est déjà résolue)
     // Dans ce mode, la condition doit être un objet avec un seul opérateur.
     if (!model) {
@@ -272,4 +339,5 @@ export const isConditionMet = (model, cond, formData, allModels, user,checkRegex
     }
 
     return evaluateSingleCondition(model, condition, formData, allModels, user, checkRegex);
-};
+};
+

package/src/modules/data/data.history.js

@@ -391,7 +391,11 @@ export function onInit(defaultEngine) {
                 }
 
                 // If this is the first history record for this document, add a snapshot of the 'before' state.
-                if (!lastVersionDoc) {
+                // --- FIX ---
+                // The check should be based on the calculated version number, not on the existence of lastVersionDoc,
+                // which could be affected by race conditions in a busy environment. If we are creating version 1,
+                // it means no prior history exists for this document, so we must add the snapshot.
+                if (newVersion === 1) {
                     historyEntry.snapshot = beforeDoc;
                     logger.debug(`History v${newVersion} (update with initial snapshot) created for ${modelName} document ${afterDoc._id}`);
                 } else {

package/src/modules/data/data.js

@@ -14,7 +14,7 @@ import i18n from "../../i18n.js";
 import checkDiskSpace from "check-disk-space";
 import {removeFile} from "../file.js";
 import {hasPermission} from "../user.js";
-import {profiles} from "../../../client/src/constants.js";
+import { onInit as userInit } from '../user.js';
 import {registerRoutes} from "./data.routes.js";
 import {mongoDBWhitelist} from "./data.core.js";
 import {onInit as relationsInit} from "./data.relations.js";
@@ -139,6 +139,7 @@ export async function onInit(defaultEngine) {
     validationInit(defaultEngine);
     relationsInit(defaultEngine);
     scheduleInit(defaultEngine);
+    userInit(defaultEngine);
     operationsInit(defaultEngine);
 
 

package/src/modules/data/data.operations.js

@@ -37,7 +37,7 @@ import {
 } from "../mongodb.js";
 import i18n from "../../i18n.js";
 import tinycolor from 'tinycolor2';
-import {Config} from "../../config.js";
+import { Config } from "../../config.js";
 import {calculateTotalUserStorageUsage, hasPermission} from "../user.js";
 import {BSON, ObjectId} from "mongodb";
 import {runScheduledJobWithDbLock, triggerWorkflows} from "../workflow.js";
@@ -45,7 +45,7 @@ import schedule from "node-schedule";
 import {sendSseToUser} from "./data.routes.js";
 import {applyCronMask, handleScheduledJobs, runStatefulAlertJob} from "./data.scheduling.js";
 import {Event} from "../../events.js";
-import {getAllPacks} from "../../packs.js";
+import { getAllPacks } from "../../packs.js";
 import {validateModelData, validateModelStructure} from "./data.validation.js";
 import {addFile, removeFile} from "../file.js";
 import NodeCache from "node-cache";
@@ -61,7 +61,8 @@ import {
     processDocuments
 } from "./data.relations.js";
 import crypto from 'crypto';
-import cronstrue from 'cronstrue/i18n.js';
+import cronstrue from 'cronstrue/i18n.js'
+import { isConditionMet } from '../../filter.js';
 import util from "node:util";
 
 const delay = ms => new Promise(res => setTimeout(res, ms));
@@ -693,14 +694,27 @@ export const getModel = async (modelName, user) => {
 export const getModels = async () => {
     return await getCollection('models')?.find({'$or': [{_user: {$exists: false}}]}).toArray() || [];
 }
-export const insertData = async (modelName, data, files, user, triggerWorkflow = true, waitForWorkflow = true) => {
+export const insertData = async (modelName, data, files, user, triggerWorkflow = true, waitForWorkflow = true, checkPermissions = true) => {
 
-    // --- Vérification des permissions (inchangée) ---
-    if (!(isDemoUser(user) && Config.Get("useDemoAccounts")) && isLocalUser(user) && (
-        !await hasPermission(["API_ADMIN", "API_ADD_DATA", "API_ADD_DATA_" + modelName], user) ||
-        await hasPermission(["API_ADD_DATA_NOT_" + modelName], user))) {
-        // Renvoyer une structure d'erreur cohérente
-        return {success: false, error: i18n.t('api.permission.addData'), statusCode: 403};
+    if (checkPermissions) {
+        // --- Vérification des permissions ---
+        const permissionFilter = await hasPermission(["API_ADMIN", "API_ADD_DATA", "API_ADD_DATA_" + modelName], user);
+        const hasDeniedPermission = await hasPermission(["API_ADD_DATA_NOT_" + modelName], user);
+
+        if (!(isDemoUser(user) && Config.Get("useDemoAccounts")) && isLocalUser(user) && (!permissionFilter || hasDeniedPermission)) {
+            return { success: false, error: i18n.t('api.permission.addData', "You do not have permission to add this data."), statusCode: 403 };
+        }
+
+        // Si un filtre de permission existe, valider les données entrantes
+        if (typeof permissionFilter === 'object' && Object.keys(permissionFilter).length > 0) {
+            const dataArray = Array.isArray(data) ? data : [data];
+            const model = await getModel(modelName, user);
+            for (const doc of dataArray) {
+                if (!isConditionMet(model, permissionFilter, doc, [], user)) {
+                    return { success: false, error: i18n.t('api.permission.addData.filterViolation', "The data you are trying to add does not meet the required permission criteria."), statusCode: 403 };
+                }
+            }
+        }
     }
 
     const collection = await getCollectionForUser(user);
@@ -1084,27 +1098,40 @@ export const editData = async (modelName, filter, data, files, user, triggerWork
 const internalEditOrPatchData = async (modelName, filter, data, files, user, isPatch, triggerWorkflow = true, waitForWorkflow = false) => {
     try {
         // 1. Vérification des permissions
-        if (user.username !== 'demo' && isLocalUser(user) && (
-            !await hasPermission(["API_ADMIN", "API_EDIT_DATA", "API_EDIT_DATA_" + modelName], user) ||
-            await hasPermission(["API_EDIT_DATA_NOT_" + modelName], user))) {
-            throw new Error(i18n.t("api.permission.editData"));
+        const permissionResult = await hasPermission(["API_ADMIN", "API_EDIT_DATA", "API_EDIT_DATA_" + modelName], user);
+        const hasDeniedPermission = await hasPermission(["API_EDIT_DATA_NOT_" + modelName], user);
+
+        if (user.username !== 'demo' && isLocalUser(user) && (!permissionResult || hasDeniedPermission)) {
+            throw new Error(i18n.t("api.permission.editData", "You do not have permission to edit this data."));
         }
 
+
         const collection = await getCollectionForUser(user);
-        const model = await modelsCollection.findOne({name: modelName, _user: user.username});
+        const model = await modelsCollection.findOne({$and : [{name: modelName}, {$or: [{_user: user._user}, {_user:user.username}]}]});
         if (!model) {
             throw new Error(i18n.t("api.model.notFound", {model: modelName}));
         }
 
-        // 2. Récupération des documents existants et de leur hash original
-        const existingDocs = (await searchData({model: modelName, filter}, user))?.data;
+        // 2. Combinaison du filtre de la requête et du filtre de permission
+        let combinedFilter = filter;
+        if (permissionResult && typeof permissionResult === 'object' && Object.keys(permissionResult).length > 0) {
+            combinedFilter = {
+                $and: [filter, permissionResult]
+            };
+        }
+
+        // 3. Récupération des documents à modifier en utilisant le filtre combiné
+        const docsToEditQuery = await searchData({model: modelName, filter: combinedFilter}, user);
+        let existingDocs = docsToEditQuery.data;
+
         if (!existingDocs || existingDocs.length === 0) {
-            return {success: false, error: i18n.t("api.data.notFound")};
+            throw new Error(i18n.t("api.data.notFound"));
         }
+
         const ids = existingDocs.map(d => new ObjectId(d._id));
         const originalHash = existingDocs[0]._hash; // Sauvegarde du hash avant modification
  
-        // 3. Préparation des données de mise à jour en séparant les opérateurs
+        // 4. Préparation des données de mise à jour en séparant les opérateurs
         const updateSetData = {};
         const updatePushData = {};
  
@@ -1164,15 +1191,10 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        // 4. Validation adaptée pour patch ou edit
-        if (!isPatch) {
-            const dataToValidate = {...existingDocs[0], ...updateSetData};
-            await validateModelData(dataToValidate, model, false);
-        } else {
-            await validateModelData(updateSetData, model, true);
-        }
+        // 5. Validation adaptée pour patch ou edit
+        await validateModelData(isPatch ? updateSetData : { ...existingDocs[0], ...updateSetData }, model, isPatch);
 
-        // 4.1 Validation pour les opérations $push
+        // 5.1 Validation pour les opérations $push
         for (const fieldName in updatePushData) {
             const field = model.fields.find(f => f.name === fieldName);
             if (!field) throw new Error(`Le champ '${fieldName}' pour l'opération $push n'existe pas dans le modèle '${model.name}'.`);
@@ -1197,7 +1219,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
         }
 
 
-        // 5. Vérification des champs uniques (s'applique uniquement aux opérations $set)
+        // 6. Vérification des champs uniques (s'applique uniquement aux opérations $set)
         const uniqueFields = model.fields.filter(f => f.unique);
         for (const field of uniqueFields) {
             if (updateData[field.name] !== undefined) {
@@ -1216,7 +1238,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        // 6. Traitement des relations (pour $set)
+        // 7. Traitement des relations (pour $set)
         const relationFields = model.fields.filter(f => f.type === 'relation');
         for (const field of relationFields) {
             if (updateData[field.name] !== undefined) {
@@ -1240,7 +1262,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        // 7. Application des filtres de champ (pour $set)
+        // 8. Application des filtres de champ (pour $set)
         for (const field of model.fields) {
             // On saute les champs 'file' car ils ont déjà été traités
             if (field.type !== 'file' && field.itemsType !== 'file' && updateData[field.name] !== undefined && dataTypes[field.type]?.filter) {
@@ -1286,7 +1308,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        // 8. Vérification des limites de stockage avant la mise à jour
+        // 9. Vérification des limites de stockage avant la mise à jour
         const originalDocsSize = calculateDataSize(existingDocs);
         const finalStateForSize = existingDocs.map(doc => {
             const updatedDoc = { ...doc, ...updateSetData };
@@ -1323,7 +1345,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        // 8. Calcul du nouveau hash en simulant l'état final
+        // 10. Calcul du nouveau hash en simulant l'état final
         const finalStateForHash = { ...existingDocs[0], ...updateSetData };
         for (const fieldName in updatePushData) {
             let itemsToAdd;
@@ -1358,7 +1380,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        // 9. *** CORRECTION LOGIQUE ***
+        // 11. *** CORRECTION LOGIQUE ***
         // On ne vérifie l'unicité que si le hash a réellement changé.
         if (newHash !== originalHash) {
             const hashCheck = await checkHash(user, model, newHash, existingDocs[0]._id.toString());
@@ -1368,7 +1390,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        // 10. Exécution de la mise à jour.
+        // 12. Exécution de la mise à jour.
         // Si une opération $push est présente, nous devons utiliser une pipeline d'agrégation
         // pour gérer de manière robuste le cas où le champ cible est `null` ou n'existe pas.
         let updateCommand;
@@ -1430,7 +1452,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             });
         }
 
-        // 11. Tâches post-mise à jour (schedules, workflows) (inchangé)
+        // 13. Tâches post-mise à jour (schedules, workflows) (inchangé)
         if (["workflowTrigger", "alert"].includes(modelName)) {
             await handleScheduledJobs(modelName, existingDocs, collection, finalUpdateOperation.$set || {});
         }
@@ -1459,40 +1481,65 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
 export const deleteData = async (modelName, filter, user = {}, triggerWorkflow, waitForWorkflow = false) => {
 
     try {
-        const collection = await getCollectionForUser(user);
+        const permissionFilter = await hasPermission(["API_ADMIN", "API_DELETE_DATA", "API_DELETE_DATA_" + modelName], user);
+        const hasDeniedPermission = await hasPermission(["API_DELETE_DATA_NOT_" + modelName], user);
 
-        // --- Début de la logique de suppression ---
+        if (user?.username !== 'demo' && isLocalUser(user) && (!permissionFilter || hasDeniedPermission)) {
+            // Si l'utilisateur n'a pas la permission de base, on arrête tout de suite.
+            return { success: false, error: i18n.t("api.permission.deleteData", "You do not have permission to delete this data."), deletedCount: 0 };
+        }
 
-        // 1. Construire le filtre de base pour trouver les documents à supprimer
-        let findFilter = [];
-        if (user)
-            findFilter.push({
-                '$eq': ["$_user", user.username]
-            });
+        const collection = await getCollectionForUser(user);
 
-        // Ajouter le filtre par IDs si fourni
-        if (Array.isArray(filter) && filter.length > 0) {
-            findFilter.push({"$in": ["$_id", filter.map(m => new ObjectId(m))]});
-        }
+        // 1. Construire le filtre de recherche.
+        // Nous allons utiliser un seul objet $match avec un $and global pour combiner toutes les conditions.
+        const matchConditions = [];
 
-        // Ajouter le filtre par nom de modèle si fourni (utile si 'filter' est utilisé seul)
-        if (modelName)
-            findFilter.push({
-                '$eq': ["$_model", modelName]
-            });
+        // Conditions de base (modèle et utilisateur)
+        if (user) {
+            matchConditions.push({ $expr: { '$eq': ["$_user", user.username] } });
+        }
+        if (modelName) {
+            matchConditions.push({ _model: modelName });
+        }
 
-        // Ajouter le filtre supplémentaire si fourni
-        if (filter && typeof filter === 'object' && Object.keys(filter).length > 0) {
-            // Fusionner prudemment le filtre supplémentaire
-            // Attention: Si 'filter' contient des clés comme _id ou _user,
-            // cela pourrait entrer en conflit. Une fusion plus robuste pourrait re nécessaire.
-            findFilter.push(filter);
-        } else {
+        // Filtre de la requête (par ID ou autre)
+        if (Array.isArray(filter) && filter.length > 0 && isObjectId(filter[0])) {
+            // Filtre par tableau d'IDs
+            matchConditions.push({ _id: { "$in": filter.map(m => new ObjectId(m)) } });
+        } else if (filter && typeof filter === 'object' && Object.keys(filter).length > 0) {
+            const firstKey = Object.keys(filter)[0];
+            // Si le filtre est une expression d'agrégation (commence par $), on l'encapsule dans $expr
+            if (firstKey.startsWith('$')) {
+                matchConditions.push({ $expr: filter });
+            } else {
+                // Sinon, on le traite comme un filtre de document standard
+                const processedFilter = {};
+                for (const key in filter) {
+                    if (key === '_id' && !isObjectId(filter[key])) {
+                        // S'assurer que la conversion ne se fait que si la chaîne est un ID valide
+                        if (ObjectId.isValid(filter[key])) {
+                            processedFilter[key] = new ObjectId(filter[key]);
+                        } else {
+                            processedFilter[key] = filter[key]; // Garder la valeur originale si non valide
+                        }
+                    } else {
+                        processedFilter[key] = filter[key];
+                    }
+                }
+                matchConditions.push(processedFilter);
+            }
+        }
 
+        // Filtre de permission
+        if (permissionFilter && typeof permissionFilter === 'object') {
+            matchConditions.push(permissionFilter);
         }
 
+        const findFilter = matchConditions.length > 0 ? { $and: matchConditions } : {};
+
         // 2. Récupérer les documents à supprimer pour vérifier leur type et annuler les schedules
-        const documentsToDelete = await collection.aggregate([{$match: {$expr: {"$and": findFilter}}}]).toArray();
+        const documentsToDelete = await collection.aggregate([{ $match: findFilter }]).toArray();
 
         if (documentsToDelete.length === 0) {
             logger.info(`[deleteData] No documents found matching the criteria for user ${user?.username}.`);
@@ -1531,15 +1578,6 @@ export const deleteData = async (modelName, filter, user = {}, triggerWorkflow,
                 await Promise.allSettled(deletePromises);
             }
 
-            // Vérification des permissions (pour chaque document trouvé)
-            if (user?.username !== 'demo' && isLocalUser(user) && (
-                !await hasPermission(["API_ADMIN", "API_DELETE_DATA", "API_DELETE_DATA_" + docToDelete._model], user) ||
-                await hasPermission(["API_DELETE_DATA_NOT_" + docToDelete._model], user))) {
-                // Si l'utilisateur n'a pas la permission pour CE document spécifique, on l'ignore
-                logger.warn(`[deleteData] User ${user.username} lacks permission to delete document ${docToDelete._id} of model ${docToDelete._model}. Skipping.`);
-                continue; // Passe au document suivant
-            }
-
             // *** Ajout de l'annulation du schedule pour workflowTrigger ***
             if (docToDelete._model === 'workflowTrigger') {
                 const jobId = `workflowTrigger_${docToDelete._id}`;
@@ -1679,9 +1717,15 @@ export const deleteData = async (modelName, filter, user = {}, triggerWorkflow,
             logger.info(`[deleteData] No documents to delete for user ${user?.username} after permission checks or matching criteria.`);
         }
 
-        const res = {success: true, deletedCount}
-        const plugin = await Event.Trigger("OnDataDeleted", "event", "system", engine, {model: modelName, filter});
-        await Event.Trigger("OnDataDeleted", "event", "user", {model: modelName, filter});
+        const res = { success: true, deletedCount };
+
+        // --- CORRECTION ---
+        // The event payload must match what the history listener expects: { modelName, user, before }.
+        // 'documentsToDelete' contains the full documents before they were deleted.
+        const eventPayload = { modelName: modelNameToInvalidate, user, before: documentsToDelete };
+        const plugin = await Event.Trigger("OnDataDeleted", "event", "system", engine, eventPayload);
+        await Event.Trigger("OnDataDeleted", "event", "user", eventPayload);
+
         return plugin || res;
 
     } catch (error) {

package/src/modules/data/data.relations.js

@@ -534,7 +534,7 @@ function prepareDocument(doc, model, me) {
     }
 
     docToProcess._model = model.name;
-    docToProcess._user = me._user || me.username;
+    docToProcess._user = me.username || me._user;
     docToProcess._hash = getFieldValueHash(model, docToProcess);
 
     return docToProcess;

package/src/modules/mongodb.js

@@ -2,6 +2,7 @@
 import {Logger} from "../gameObject.js";
 import {MongoDatabase} from "../engine.js";
 import {ObjectId} from "mongodb";
+import {isLocalUser} from "../data.js";
 
 export let modelsCollection, datasCollection, filesCollection, packsCollection;
 
@@ -51,7 +52,7 @@ export const getCollection = (str) => {
 // New function to determine the collection name for a user
 export const getUserCollectionName = async (user) => {
     const feat = await engine.userProvider.hasFeature(user, 'indexes');
-    return feat ? `datas_${user.username}` : 'datas';
+    return feat ? (isLocalUser(user) ? `datas_${user._user}` :`datas_${user.username}` ) : 'datas';
 };
 
 

package/src/modules/swagger.js

@@ -10,9 +10,29 @@ let engine, logger;
 export async function onInit(defaultEngine) {
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
-
-    const swaggerDocument = YAML.parse(fs.readFileSync(process.cwd() + '/swagger-en.yml', 'utf8'));
-
-    engine.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));
-
+    
+    const swaggerDocs = {
+        en: YAML.parse(fs.readFileSync(process.cwd() + '/swagger-en.yml', 'utf8')),
+        fr: YAML.parse(fs.readFileSync(process.cwd() + '/swagger-fr.yml', 'utf8'))
+    };
+    
+    // Sers les assets de swagger-ui
+    engine.use('/api-docs', swaggerUi.serve);
+    
+    // Route pour la langue par défaut (ex: /api-docs)
+    engine.get('/api-docs', (req, res) => {
+        return swaggerUi.setup(swaggerDocs['en'])(req, res);
+    });
+    
+    // Route pour une langue spécifique (ex: /api-docs/fr)
+    engine.get('/api-docs/:lang', (req, res) => {
+        const lang = req.params.lang;
+    
+        // Si la langue demandée n'existe pas, on redirige vers la version anglaise.
+        if (!swaggerDocs[lang]) {
+            return res.redirect('/api-docs/en');
+        }
+    
+        return swaggerUi.setup(swaggerDocs[lang])(req, res);
+    });
 };