data-primals-engine 1.6.3 → 1.6.5

package/src/filter.js

@@ -1,7 +1,3 @@
-import {getCollectionForUser, isObjectId} from "./modules/mongodb.js";
-import {getModel} from "./modules/data/index.js";
-import {ObjectId} from "mongodb";
-import {safeAssignObject} from "./core.js";
 
 let safeRegex = null; // Par défaut, aucune fonction de validation n'est définie.
 
@@ -13,6 +9,47 @@ 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é.
@@ -67,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];
@@ -81,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.");
@@ -165,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);
@@ -189,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) => {
@@ -237,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) {
@@ -314,131 +341,3 @@ export const isConditionMet = (model, cond, formData, allModels, user,checkRegex
     return evaluateSingleCondition(model, condition, formData, allModels, user, checkRegex);
 };
 
-
-
-/**
- * Remplace les placeholders dans un template (string, object, array) par des valeurs du contextData.
- * Version améliorée avec support des chemins complexes via resolvePathValue.
- */
-export async function substituteVariables(template, contextData, user) {
-    // 1. Retourner les types non substituables tels quels
-    if (template === null || (typeof template !== 'string' && typeof template !== 'object')) {
-        return template;
-    }
-
-    // 2. Gérer les tableaux de manière récursive
-    if (Array.isArray(template)) {
-        return Promise.all(template.map(item => substituteVariables(item, contextData, user)));
-    }
-
-    // 3. Gérer les objets de manière récursive
-    if (typeof template === 'object') {
-        const newObj = {};
-        for (const key in template) {
-            if (Object.prototype.hasOwnProperty.call(template, key)) {
-                const val = await substituteVariables(template[key], contextData, user);
-                safeAssignObject(newObj, key, val);
-            }
-        }
-        return newObj;
-    }
-
-    // --- À partir d'ici, nous savons que `template` est une chaîne de caractères ---
-
-    // 4. Construire le contexte complet pour la substitution
-    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 }), {});
-
-    // `contextToSearch` contient toutes les données disponibles à sa racine
-    const contextToSearch = { ...contextData, env: userEnv };
-
-    // 5. Logique de résolution de valeur améliorée avec resolvePathValue
-    const findValue = async (key) => {
-        let path = key.trim();
-        if (path.startsWith('context.')) {
-            path = path.substring('context.'.length);
-        }
-        if (path.endsWith('._id')) {
-            const basePath = path.slice(0, -4);
-            const value = await findValue(basePath);
-            return value?._id?.toString(); // Convertit l'ObjectId en string
-        }
-
-        // Gérer les valeurs dynamiques spéciales
-        if (path === 'now') {
-            return new Date().toISOString();
-        } else if (path === 'randomUUID') {
-            return crypto.randomUUID();
-        } else if( path === "baseUrl" ){
-            return process.env.NODE_ENV === 'production' ? 'https://'+getHost()+'/' : 'http://localhost:/'+port;
-        }
-
-        // Détecter si le chemin est complexe (contient plus d'un point)
-        if (path.split('.').length > 1) {
-            try {
-                // Essayer de résoudre le chemin avec resolvePathValue
-                const [root, ...rest] = path.split('.');
-                // On vérifie si la racine du chemin (ex: 'triggerData') existe dans notre contexte
-                if (contextToSearch[root]) {
-                    const resolvedValue = await resolvePathValue(
-                        rest.join('.'),
-                        contextToSearch[root], // On passe le bon objet de départ (ex: l'objet triggerData)
-                        user
-                    );
-                    if (resolvedValue !== undefined) {
-                        return resolvedValue;
-                    }
-                }
-            } catch (error) {
-                console.warn(`Erreur lors de la résolution du chemin "${path}":`, error.message);
-                // On continue avec la méthode normale si la résolution échoue
-            }
-        }
-
-        // Fallback: chercher le chemin dans l'objet de contexte normal
-        return getNestedValue(contextToSearch, path);
-    };
-
-    // CAS A : La chaîne est un unique placeholder (ex: "{context.triggerData.product.price}")
-    const singlePlaceholderMatch = template.match(/^\{([^}]+)\}$/);
-    if (singlePlaceholderMatch) {
-        const key = singlePlaceholderMatch[1];
-        const value = await findValue(key);
-
-        if (value === undefined) {
-            return template; // Placeholder not found, return as is.
-        }
-
-        // If the resolved value is a string, it might contain more placeholders.
-        // We recursively call substituteVariables on it, but only if it's different
-        // from the original template to prevent infinite loops.
-        if (typeof value === 'string' && value !== template) {
-            return substituteVariables(value, contextData, user);
-        }
-
-        // For non-string values or if value is same as template, return the value.
-        return value;
-    }
-
-    // CAS B : La chaîne contient plusieurs placeholders ou mix texte/variables
-    const placeholderRegex = /\{([^}]+)\}/g;
-    const placeholders = [...template.matchAll(placeholderRegex)];
-
-    // Si aucun placeholder trouvé, retourner la chaîne telle quelle
-    if (placeholders.length === 0) {
-        return template;
-    }
-
-    // Remplacer chaque placeholder de manière asynchrone
-    let result = template;
-    for (const [match, key] of placeholders) {
-        const value = await findValue(key);
-        const replacement = value !== undefined
-            ? (value === null ? 'null' : typeof value === 'object' ? JSON.stringify(value) : String(value))
-            : match;
-        result = result.replace(match, replacement);
-    }
-
-    return result;
-}

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);
+
+        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 };
+        }
 
-        // --- Début de la logique de suppression ---
+        const collection = await getCollectionForUser(user);
 
-        // 1. Construire le filtre de base pour trouver les documents à supprimer
-        let findFilter = [];
-        if (user)
-            findFilter.push({
-                '$eq': ["$_user", user.username]
-            });
+        // 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 IDs si fourni
-        if (Array.isArray(filter) && filter.length > 0) {
-            findFilter.push({"$in": ["$_id", filter.map(m => new ObjectId(m))]});
+        // 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 par nom de modèle si fourni (utile si 'filter' est utilisé seul)
-        if (modelName)
-            findFilter.push({
-                '$eq': ["$_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}`;

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';
 };