data-primals-engine 1.6.2-rc1 → 1.6.3

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

@@ -1,3 +1,7 @@
+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.
 
@@ -9,6 +13,42 @@ export function setSafeRegex(validator) {
     safeRegex = validator;
 }
 
+/**
+ * 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.
@@ -272,4 +312,133 @@ 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/assistant/assistant.js

@@ -1,7 +1,8 @@
 import { getCollectionForUser, modelsCollection } from "../mongodb.js";
 import { Logger } from "../../gameObject.js";
 import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import {searchData,  patchData, deleteData, insertData} from "../data/index.js";
+import { searchData, patchData, deleteData, insertData } from "../data/index.js";
+import { getAIProvider } from "./providers.js";
 import {providers} from "./constants.js";
 import {Config} from "../../config.js";
 import { Event } from "../../events.js";
@@ -13,38 +14,6 @@ import {parseSafeJSON} from "../../core.js";
 
 let logger = null;
 
-export const getAIProvider= async (aiProvider, aiModel, apiKey)=>{
-    const maxTokens = Config.Get('assistant.maxTokens', assistantConfig.maxTokens);
-    try {
-        switch (aiProvider) {
-        case 'OpenAI': {
-            const { ChatOpenAI } = await import("@langchain/openai");
-            return new ChatOpenAI({apiKey, model: aiModel, temperature: 0.7, maxTokens});
-        }
-        case 'Google': {
-            const { ChatGoogleGenerativeAI } = await import("@langchain/google-genai");
-            return new ChatGoogleGenerativeAI({apiKey, model: aiModel, temperature: 0.7, maxTokens});
-        }
-        case 'DeepSeek': {
-            const { ChatDeepSeek } = await import("@langchain/deepseek");
-            return new ChatDeepSeek({apiKey, model: aiModel, temperature: 0.7, maxTokens});
-        }
-        case 'Anthropic': {
-            const { ChatAnthropic } = await import("@langchain/anthropic");
-            return new ChatAnthropic({apiKey, model: aiModel, temperature: 0.7, maxTokens});
-        }
-        default:
-            throw new Error(`Unsupported AI provider: ${aiProvider}`);
-        }
-    } catch (e) {
-        if (e.code === 'ERR_MODULE_NOT_FOUND') {
-            logger.error(`[Assistant] The package for the '${aiProvider}' provider is not installed. Please run 'npm install @langchain/${aiProvider.toLowerCase()}' to use this provider.`);
-            throw new Error(`The AI provider '${aiProvider}' is not installed. Please ask the administrator to install the corresponding package.`);
-        }
-        logger.error(`[Assistant] Error initializing AI provider '${aiProvider}': ${e.message}`);
-        throw e; // Re-throw other errors
-    }
-}
 export const assistantGlobalLimiter = rateLimit({
     windowMs: 15 * 60 * 1000, // Fenêtre de 15 minutes
     max: 100, // Limite à 100 requêtes globales pour l'assistant pendant la fenêtre (vous pouvez ajuster cette valeur)
@@ -101,7 +70,7 @@ const createSystemPrompt = (modelDefs, lang) => {
 
     const date = new Date();
     const dt = date.toISOString();
-    return `
+    return Config.Get('systemPrompt', `
 Tu es "Prior", un assistant expert en analyse de données pour le moteur data-primals-engine..
 Ta mission est d'aider l'utilisateur en répondant à ses questions sur ses données.
 
@@ -333,7 +302,7 @@ Ma question: Bonjour, je voudrais les requêtes effectuées aujourd'hui sur le m
 Ta réponse: [
   { "action" : "search_models", "params": { "query": "request" } },
   { "action" : "search", "params" : { "model": "request", "filter": { "$and": [{"$gte": ["$createdAt", "${dt}"]}, {"$regexMatch": { "input": "$url", "regex": "content"}}] }, "limit" : 10, "sort" : "_id:DESC" } }
-]`;
+]`);
 }
 
 /**
@@ -475,7 +444,7 @@ export async function handleChatRequest(params, user, sendEvent = null) {
         return errorResult;
     }
 
-    const systemPrompt = await Event.Trigger('OnSystemPrompt', 'event', 'user', user);
+    const systemPrompt = (await Event.Trigger('OnSystemPrompt', 'event', 'user', user)) || createSystemPrompt([], user.lang || 'en');
 
     const conversationHistory = (history || [])
         .filter(msg => msg.text && !(msg.from === 'bot' && msg.text.startsWith(i18n.t('assistant.welcome'))))
@@ -559,11 +528,12 @@ export async function handleChatRequest(params, user, sendEvent = null) {
             return result;
         }
         
-        let hasContinued = false;
+        const toolResults = [];
+        let finalActionResult = null;
+
         for (const command of commands) {
             logger.debug(`[Assistant] Action décidée par l'IA: ${command.action}`, command);
             if (sendEvent) sendEvent('action', { action: command.action, params: command.params });
-            conversationHistory.push(new SystemMessage(JSON.stringify(command)));
 
             const { action, params: parsedParams } = command;
 
@@ -576,40 +546,52 @@ export async function handleChatRequest(params, user, sendEvent = null) {
             // Outils pour le raisonnement interne de l'IA
             if (['search_models'].includes(action)) {
                 const toolResult = await executeTool(action, parsedParams, user, allModels);
-                if (sendEvent) sendEvent('tool_result', { action, result: toolResult });
-                conversationHistory.push(new SystemMessage(`Résultat de l'outil '${action}':\n${toolResult}`));
-                hasContinued = true; // On indique qu'on doit continuer la boucle principale
-                continue; // On passe à la commande suivante dans la liste de l'IA
+                toolResults.push({ action, result: toolResult });
+                continue; // Passe à la commande suivante sans vérifier si c'est une action finale
             }
 
             // Actions finales
-            const res = await Event.Trigger('OnChatAction', 'event', 'user', action, params, command, llmOptions, user);
+            const res = await Event.Trigger('OnChatAction', 'event', 'user', action, parsedParams, command, llmOptions, user, params);
 
-            if (!res) {
+            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
+            } 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}`);
-                const result = {
+                finalActionResult = {
                     success: true,
                     displayMessage: i18n.t('assistant.unknownAction', "Désolé, je ne comprends pas la commande '{{action}}'.", { action })
                 };
-                if (sendEvent) {
-                    sendEvent('final_result', result);
-                    return;
-                }
-                return result;
+                break; // Sortir de la boucle des commandes
             }
-            // Une action finale a été trouvée, on retourne son résultat et on arrête le traitement.
+        }
+
+        // Si une action finale a été exécutée, on retourne son résultat.
+        if (finalActionResult) {
             if (sendEvent) {
-                sendEvent('final_result', res);
+                sendEvent('final_result', finalActionResult);
                 return;
             }
-            return res;
+            return finalActionResult;
         }
 
-        // Si on a traité des outils de raisonnement, on relance la boucle de l'IA
-        if (hasContinued) {
+        // Si on a uniquement des résultats d'outils, on les ajoute à l'historique et on continue la boucle.
+        if (toolResults.length > 0) {
+            let toolResponse = "";
+            for (const tool of toolResults) {
+                if (sendEvent) sendEvent('tool_result', { action: tool.action, result: tool.result });
+                toolResponse += `Résultat de l'outil '${tool.action}':\n${tool.result}\n\n`;
+            }
+            conversationHistory.push(new SystemMessage(toolResponse));
             continue;
         }
+
+        // Si l'IA ne retourne ni outil ni action finale reconnue, on arrête.
+        if (commands.length > 0) {
+            logger.warn(`[Assistant] L'IA a retourné des commandes mais aucune n'était un outil ou une action finale reconnue. Commandes:`, commands);
+        }
     }
 
     // Si la boucle se termine sans une action finale
@@ -656,7 +638,7 @@ async function executeConfirmedAction(action, params, user) {
  * @param {object} user - L'objet utilisateur.
  * @returns {Promise<object|boolean>} - L'objet de réponse final ou false si l'action n'est pas reconnue.
  */
-async function handleFinalChatAction(action, params, parsedResponse, user) {
+async function handleFinalChatAction(action, params, parsedResponse, llmOptions, user) {
     // Action de génération de graphique, gérée par le front-end
     if (action === 'generateChart') {
         return {success: true, chartConfig: params};

package/src/modules/assistant/providers.js

@@ -0,0 +1,38 @@
+import { Config } from "../../config.js";
+import { assistantConfig } from "../../constants.js";
+import { Logger } from "../../gameObject.js";
+
+const logger = new Logger("AssistantProviders");
+
+export const getAIProvider = async (aiProvider, aiModel, apiKey) => {
+    const maxTokens = Config.Get('assistant.maxTokens', assistantConfig.maxTokens);
+    try {
+        switch (aiProvider) {
+            case 'OpenAI': {
+                const { ChatOpenAI } = await import("@langchain/openai");
+                return new ChatOpenAI({ apiKey, model: aiModel, temperature: 0.7, maxTokens });
+            }
+            case 'Google': {
+                const { ChatGoogleGenerativeAI } = await import("@langchain/google-genai");
+                return new ChatGoogleGenerativeAI({ apiKey, model: aiModel, temperature: 0.7, maxTokens });
+            }
+            case 'DeepSeek': {
+                const { ChatDeepSeek } = await import("@langchain/deepseek");
+                return new ChatDeepSeek({ apiKey, model: aiModel, temperature: 0.7, maxTokens });
+            }
+            case 'Anthropic': {
+                const { ChatAnthropic } = await import("@langchain/anthropic");
+                return new ChatAnthropic({ apiKey, model: aiModel, temperature: 0.7, maxTokens });
+            }
+            default:
+                throw new Error(`Unsupported AI provider: ${aiProvider}`);
+        }
+    } catch (e) {
+        if (e.code === 'ERR_MODULE_NOT_FOUND') {
+            logger.error(`[Assistant] The package for the '${aiProvider}' provider is not installed. Please run 'npm install @langchain/${aiProvider.toLowerCase()}' to use this provider.`);
+            throw new Error(`The AI provider '${aiProvider}' is not installed. Please ask the administrator to install the corresponding package.`);
+        }
+        logger.error(`[Assistant] Error initializing AI provider '${aiProvider}': ${e.message}`);
+        throw e; // Re-throw other errors
+    }
+}

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

@@ -323,17 +323,14 @@ export function onInit(defaultEngine) {
     engine.post('/api/data/history/:modelName/:recordId/revert/:version', [middlewareAuthenticator, userInitiator], handleRevertToRevisionRequest);
 
     // --- Écouteur pour la CRÉATION de données (Version 1 - Snapshot) ---
-    Event.Listen("OnDataAdded", async (engine, { modelName, insertedIds, user }) => {
+    Event.Listen("OnDataAdded", async (engine, { modelName, insertedDocs, user }) => {
         try {
             const model = await getModel(modelName, user);
             if (!model?.history?.enabled) return;
 
-            const dataCollection = await getCollectionForUser(user);
             const historyCollection = getCollection('history');
 
-            const newDocs = await dataCollection.find({ _id: { $in: insertedIds.map(id => new ObjectId(id)) } }).toArray();
-
-            for (const doc of newDocs) {
+            for (const doc of insertedDocs) {
                 await historyCollection.insertOne({
                     documentId: doc._id,
                     model: modelName,
@@ -394,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.operations.js

@@ -817,7 +817,7 @@ export const insertData = async (modelName, data, files, user, triggerWorkflow =
         }
 
         // System specific event
-        const eventPayload = {modelName, insertedIds, user};
+        const eventPayload = {modelName, insertedDocs, user};
         await Event.Trigger("OnDataAdded", "event", "system", engine, eventPayload);
 
         // User specific event
@@ -829,7 +829,10 @@ export const insertData = async (modelName, data, files, user, triggerWorkflow =
         // --- CORRECTION ---
         // On renvoie l'objet complet du premier document inséré (cas le plus courant pour l'undo)
         // et la liste complète des IDs pour les cas de bulk insert.
-        const firstInsertedDoc = insertedDocs.length > 0 ? insertedDocs[0] : null;
+        let firstInsertedDoc = insertedDocs.length > 0 ? { ...insertedDocs[0] } : null;
+        if (firstInsertedDoc?._id) {
+            firstInsertedDoc._id = firstInsertedDoc._id.toString();
+        }
         return {success: true, data: firstInsertedDoc, insertedIds: insertedIds.map(id => id.toString())};
 
     } catch (error) { // Attrape les erreurs de permission ou de pushDataUnsecure
@@ -1419,6 +1422,12 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
                 before: existingDocs, // Documents avant la modification
                 after: updatedDocs     // Documents après la modification
             });
+            await Event.Trigger("OnDataEdited", "event", "user", engine, {
+                modelName,
+                user,
+                before: existingDocs, // Documents avant la modification
+                after: updatedDocs     // Documents après la modification
+            });
         }
 
         // 11. Tâches post-mise à jour (schedules, workflows) (inchangé)
@@ -1670,9 +1679,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) {