data-primals-engine 1.6.3 → 1.7.0

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/migrate.js

@@ -24,7 +24,7 @@ engine.start(port, async () => {
     const target = process.argv[3]; // Le nom du fichier de migration cible
 
     try {
-        const db = MongoDatabase;
+        const db = MongoDatabase();
         const { executedNames, allMigrationFiles } = await getMigrationStatus(db);
 
         switch (command) {

package/src/modules/assistant/assistant.js

@@ -8,7 +8,7 @@ import {Config} from "../../config.js";
 import { Event } from "../../events.js";
 import rateLimit from "express-rate-limit";
 import {generateLimiter} from "../user.js";
-import {assistantConfig, maxAIReflectiveSteps} from "../../constants.js";
+import {maxAIReflectiveSteps} from "../../constants.js";
 import i18n from "../../i18n.js";
 import {parseSafeJSON} from "../../core.js";
 
@@ -80,16 +80,15 @@ REGLE FONDATRICE : suis les règles et ne dévie pas du chemin.
 STYLE UTILISE : apporte l'information au plus rapide, sans détours, ni sollicitation à l'utilisateur, ou à des tiers.
 
 FORMAT DE RÉPONSE OBLIGATOIRE :
-Ta réponse DOIT être un objet JSON unique OU un tableau d'objets JSON. Chaque objet doit contenir exactement 2 champs :
+Ta réponse DOIT être un tableau d'objets JSON (Même pour une seule action). Chaque objet doit contenir exactement 2 champs :
 1. "action" (string) 
 2. "params" (object)
 
-- Pour une action simple, retourne un objet : { "action": "...", "params": {...} }
-- Pour enchaîner plusieurs actions, retourne un tableau :
-  [
-    { "action": "search_models", "params": {"query": "..."} },
-    { "action": "displayMessage", "params": { "message": "Je cherche les modèles..." } }
-  ]
+Exemple :
+[
+  { "action": "search_models", "params": {"query": "..."} },
+  { "action": "displayMessage", "params": { "message": "Je cherche les modèles..." } }
+]
 
 Tu as accès aux outils et actions suivants.
 
@@ -529,7 +528,7 @@ export async function handleChatRequest(params, user, sendEvent = null) {
         }
         
         const toolResults = [];
-        let finalActionResult = null;
+        const finalActionResults = [];
 
         for (const command of commands) {
             logger.debug(`[Assistant] Action décidée par l'IA: ${command.action}`, command);
@@ -554,27 +553,31 @@ export async function handleChatRequest(params, user, sendEvent = null) {
             const res = await Event.Trigger('OnChatAction', 'event', 'user', action, parsedParams, command, llmOptions, user, params);
 
             if (res) {
-                // On a trouvé une action finale. On la stocke et on arrête de chercher.
-                finalActionResult = res;
-                break; // Sort de la boucle des commandes
+                if (res.isToolResult) {
+                    toolResults.push({ action, result: res.toolResult || res.displayMessage });
+                } else {
+                    // On a trouvé une action finale. On la stocke.
+                    finalActionResults.push(res);
+                }
             } else {
                 // Si l'action n'est reconnue par aucune des logiques ci-dessus
                 logger.warn(`[Assistant] Action non reconnue reçue de l'IA: ${action}`);
-                finalActionResult = {
+                finalActionResults.push({
                     success: true,
                     displayMessage: i18n.t('assistant.unknownAction', "Désolé, je ne comprends pas la commande '{{action}}'.", { action })
-                };
-                break; // Sortir de la boucle des commandes
+                });
             }
         }
 
-        // Si une action finale a été exécutée, on retourne son résultat.
-        if (finalActionResult) {
+        // Si une ou plusieurs actions finales ont été exécutées, on retourne le résultat.
+        if (finalActionResults.length > 0) {
+            // Rétrocompatibilité : si un seul résultat, on renvoie l'objet directement. Sinon, on renvoie un tableau 'results'.
+            const response = finalActionResults.length === 1 ? finalActionResults[0] : { success: true, results: finalActionResults };
             if (sendEvent) {
-                sendEvent('final_result', finalActionResult);
+                sendEvent('final_result', response);
                 return;
             }
-            return finalActionResult;
+            return response;
         }
 
         // Si on a uniquement des résultats d'outils, on les ajoute à l'historique et on continue la boucle.
@@ -673,7 +676,14 @@ async function handleFinalChatAction(action, params, parsedResponse, llmOptions,
 
     // Actions nécessitant une confirmation de l'utilisateur
     if (['post', 'update', 'delete'].includes(action)) {
-        return { success: true, displayMessage: i18n.t('assistant.confirmActionPrompt', "Veuillez confirmer l'action suivante :"), confirmationRequest: parsedResponse };
+        return {
+            success: true,
+            displayMessage: i18n.t('assistant.confirmActionPrompt', "Veuillez confirmer l'action suivante :"),
+            confirmationRequest: parsedResponse,
+            model: params.model,
+            filter: params.filter,
+            data: params.data
+        };
     }
 
     // Action finale pour afficher un message

package/src/modules/data/data.backup.js

@@ -8,7 +8,7 @@ import {downloadFromS3, getUserS3Config, listS3Backups, uploadToS3} from "../buc
 import fs from "node:fs";
 import {modelsCache, runCryptoWorkerTask} from "./data.core.js";
 import * as tar from "tar";
-import {getCollection, getUserCollectionName, modelsCollection} from "../mongodb.js";
+import {getCollection, getDatabase, getUserCollectionName, modelsCollection} from "../mongodb.js";
 import {removeFile} from "../file.js";
 import {cancelAlerts, scheduleAlerts} from "./data.scheduling.js";
 import {dbName} from "../../constants.js";
@@ -136,7 +136,7 @@ export const loadFromDump = async (user, options = {}) => {
         await tar.extract({file: backupFilePath, gzip: true, C: tmpRestoreDir, sync: true});
 
         // ... (Cleaning logic: deleteMany, removeFile, cancelAlerts) ...
-        const datasCollection = getCollection("datas");
+        const datasCollection = getCollection(Config.Get('dataCollection', 'datas'));
         if (modelsOnly) {
             await modelsCollection.deleteMany({_user: user.username});
         } else {
@@ -169,7 +169,7 @@ export const loadFromDump = async (user, options = {}) => {
             args.push('--nsInclude', `${d}.models`);
         } else {
             // mongorestore accepte plusieurs fois l'option --nsInclude
-            args.push('--nsInclude', `${d}.datas`);
+            args.push('--nsInclude', `${d}.${Config.Get('dataCollection', 'datas')}`);
             args.push('--nsInclude', `${d}.models`);
         }
         // Le répertoire source est le dernier argument
@@ -245,7 +245,7 @@ export const dumpUserData = async (user) => {
 
 
         const d = Config.Get('dbName', dbName);
-        const collections = await MongoDatabase.listCollections().toArray();
+        const collections = await getDatabase().listCollections().toArray();
         for (const collection of collections) {
             const collsToBackup = [await getUserCollectionName(user), 'models'];
             if (collsToBackup.includes(collection.name)) {

package/src/modules/data/data.js

@@ -2,7 +2,7 @@ import {Logger} from "../../gameObject.js";
 import {mkdir} from 'node:fs/promises';
 import {onInit as historyInit} from "./data.history.js";
 import {isDemoUser, isLocalUser} from "../../data.js";
-import {install, maxAlertsPerUser, maxRequestData, storageSafetyMargin} from "../../constants.js";
+import {install, storageSafetyMargin} from "../../constants.js";
 import {createCollection, getCollection} from "../mongodb.js";
 import path from "node:path";
 import {isGUID, sequential} from "../../core.js";
@@ -10,19 +10,19 @@ 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 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";
-import {validateField, onInit as validationInit} from "./data.validation.js";
+import { onInit as validationInit} from "./data.validation.js";
 import {cancelAlerts, scheduleAlerts, onInit as scheduleInit} from "./data.scheduling.js";
 import {deleteData, installPack, onInit as operationsInit} from "./data.operations.js";
 import {jobDumpUserData, onInit as backupInit} from "./data.backup.js";
 import {Config} from "../../config.js";
+import {profiles} from "../../profiles.js";
 
 let engine;
 let logger;
@@ -57,7 +57,7 @@ export async function onInit(defaultEngine) {
 
     const i = Config.Get('install', install);
     if( i ) {
-        datasCollection = await createCollection("datas");
+        datasCollection = await createCollection(Config.Get('dataCollection', 'datas'));
         historyCollection = await createCollection("history");
         filesCollection = await createCollection("files");
         packsCollection = await createCollection("packs");
@@ -127,7 +127,7 @@ export async function onInit(defaultEngine) {
 
     }else {
         modelsCollection = getCollection("models");
-        datasCollection = getCollection("datas");
+        datasCollection = getCollection(Config.Get('dataCollection','datas'));
         filesCollection = getCollection("files");
         packsCollection = getCollection("packs");
         historyCollection = getCollection("history");
@@ -139,6 +139,7 @@ export async function onInit(defaultEngine) {
     validationInit(defaultEngine);
     relationsInit(defaultEngine);
     scheduleInit(defaultEngine);
+    userInit(defaultEngine);
     operationsInit(defaultEngine);
 
 
@@ -255,7 +256,7 @@ export async function handleDemoInitialization(req, res) {
 
     try {
         // 1. Nettoyage de l'environnement (inchangé)
-        const datasCollection = getCollection("datas");
+        const datasCollection = getCollection(Config.Get('dataCollection',"datas"));
         const modelsCollection = getCollection("models");
         const filesCollection = getCollection("files");