data-primals-engine 1.2.6 → 1.3.1

package/src/engine.js

@@ -198,7 +198,7 @@ export const Engine = {
                     logger.warn(`Aucun point d'entrée trouvé pour le module '${moduleIdentifier}'.`);
                 }
             } catch (e) {
-                logger.error(`Échec du chargement du module '${moduleIdentifier}':`, e.stack);
+                logger.error(`Could not load module '${moduleIdentifier}':`, e.stack);
             }
         }
 
@@ -246,12 +246,12 @@ export const Engine = {
                 process.exit(1);
             });
 
-            Event.Trigger("OnServerStart", "event", "system", engine);
+            await Event.Trigger("OnServerStart", "event", "system", engine);
         }
 
         engine.stop = async () => {
             await server.close();
-            Event.Trigger("OnServerStop", "event", "system", engine);
+            await Event.Trigger("OnServerStop", "event", "system", engine);
         };
 
         async function setupInitialModels() {
@@ -262,7 +262,7 @@ export const Engine = {
 
             for(let i = 0; i < ms.length; ++i){
                 const model = ms[i];
-                validateModelStructure(model);
+                await validateModelStructure(model);
                 // Création des modèles
                 if( !dbModels.find(m =>m.name === model.name) )
                 {
@@ -274,11 +274,11 @@ export const Engine = {
                     logger.info('Model loaded (' + model.name + ')');
             }
             logger.info("All models loaded.");
-            Event.Trigger("OnModelsLoaded", "event", "system", engine, dbModels);
+            await Event.Trigger("OnModelsLoaded", "event", "system", engine, dbModels);
         }
         engine.resetModels = async () => {
             await deleteModels();
-            Event.Trigger("OnModelsDeleted", "event", "system", engine);
+            await Event.Trigger("OnModelsDeleted", "event", "system", engine);
         };
         return engine;
     }

package/src/events.js

@@ -12,14 +12,20 @@ const eventLayerSystems = {
 
 
 export const Event = {
-    Trigger: (name, system = "priority", layer = "medium", ...args) => {  // Ajout des arguments system et layer
+    Trigger: async (name, system = "priority", layer = "medium", ...args) => {  // Ajout des arguments system et layer
+        if (!name || typeof name !== 'string') {
+            throw new Error('Event name must be a non-empty string');
+        }
+
         if (!events[system] || !events[system][name] || (layer && !events[system][name][layer])) {
             //console.warn(`No trigger found for ${name} in system ${system} layer ${layer}`);
             return null;
         }
 
         const systemsToProcess = system ? [system] : Object.keys(events); // Si system est spécifié, on cible ce système uniquement, sinon tous les systèmes
-
+        console.log(`[Event] Triggering ${system}.${layer}.${name}`, {
+            callbacks: events[system]?.[name]?.[layer]?.length || 0
+        });
         let ret = null;
         for (const currentSystem of systemsToProcess) {
             if (events[currentSystem] && events[currentSystem][name]) {
@@ -30,12 +36,12 @@ export const Event = {
                         if (events[currentSystem][name][currentLayer]) {
                             for (const callback of events[currentSystem][name][currentLayer]) {
                                 try {
-                                    const res = callback(...args);
+                                    const res = await callback(...args);
                                     if (typeof res === "object" && !Array.isArray(res)) {
                                         if (typeof ret !== "object") ret = {};
                                         ret = {...ret, ...res};
                                     } else if (Array.isArray(res)) {
-                                        if (!Array.isArray(ret)) ret = [];
+                                        if (!ret || !Array.isArray(ret)) ret = [];
                                         ret = ret.concat(res);
                                     } else if (typeof res === "string") {
                                         if (typeof ret !== "string") ret = "";
@@ -50,7 +56,11 @@ export const Event = {
                                         ret = res || ret;
                                     }
                                 } catch (error) {
-                                    console.error(`Error in callback for event ${name} in system ${currentSystem} layer ${currentLayer}:`, error);
+                                    const errorMsg = `Error in callback for event ${name} in system ${currentSystem} layer ${currentLayer}: ${error.message}`;
+                                    const newError = new Error(errorMsg);
+                                    newError.originalError = error; // Conserve l'erreur originale
+                                    newError.eventDetails = { name, system: currentSystem, layer: currentLayer };
+                                    throw newError;
                                 }
                             }
                         }

package/src/gameObject.js

@@ -61,35 +61,6 @@ export class MovableBehaviour extends Behaviour {
         this.gameObject.x += this.speed;
     }
 }
-
-// UsableBehavior.js
-export class UsableBehaviour extends Behaviour {
-    constructor(gameObject) {
-        super(gameObject);
-    }
-
-    use() {
-        Event.Trigger("GameObject.UsableBehavior.use",  "system", "calls", this);
-    }
-}
-
-const mainDriver = GameObject.Create("MainDrivers");
-
-// Exemple d'attachement de comportements
-mainDriver.addComponent(MovableBehaviour, 10);
-mainDriver.addComponent(UsableBehaviour);
-
-// Accéder et utiliser les composants
-const movable = mainDriver.getComponent(MovableBehaviour);
-if (movable) {
-    movable.update();
-}
-const usable = mainDriver.getComponent(UsableBehaviour);
-if (usable) {
-    usable.use();
-}
-
-
 export class Logger extends Behaviour {
     constructor(gameObject) {
         super(gameObject);

package/src/i18n.js

@@ -1121,7 +1121,7 @@ export const translations = {
             "CreateData": "Créer une donnée",
             "DeleteData": "Supprimer une donnée",
             "ExecuteScript": "Exécuter un script",
-            "CallWebhook": "Appeler un Webhook",
+            "HttpRequest": "Appeler un Webhook",
             "SendEmail": "Envoyer un Email",
             "Wait": "Attendre",
             "GenerateAIContent": "Générer un contenu IA",

package/src/modules/{assistant.js → assistant/assistant.js}

@@ -1,17 +1,45 @@
-import { getCollectionForUser, modelsCollection } from "./mongodb.js";
-import { Logger } from "../gameObject.js";
+import { getCollectionForUser, modelsCollection } from "../mongodb.js";
+import { Logger } from "../../gameObject.js";
 import { ChatOpenAI } from "@langchain/openai";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import {searchData,  patchData, deleteData, insertData} from "./data/index.js";
-import { getDataAsString } from "../data.js";
-import i18n from "../../src/i18n.js";
-import {generateLimiter} from "./user.js";
+import {searchData,  patchData, deleteData, insertData} from "../data/index.js";
+import { getDataAsString } from "../../data.js";
+import i18n from "../../i18n.js";
+import {generateLimiter} from "../user.js";
 import rateLimit from "express-rate-limit";
-import {maxAIReflectiveSteps} from "../constants.js";
+import {maxAIReflectiveSteps} from "../../constants.js";
+import {providers} from "./constants.js";
+import {ChatDeepSeek} from "@langchain/deepseek";
+import {ChatAnthropic} from "@langchain/anthropic";
 
 let logger = null;
 
+export const getAIProvider= (aiProvider, aiModel, apiKey)=>{
+    let llm;
+    try {
+        switch (aiProvider) {
+        case 'OpenAI':
+            llm = new ChatOpenAI({apiKey, model: aiModel, temperature: 0.7});
+            break;
+        case 'Google':
+            llm = new ChatGoogleGenerativeAI({apiKey, model: aiModel, temperature: 0.7});
+            break;
+        case 'DeepSeek':
+            llm = new ChatDeepSeek({apiKey, model: aiModel, temperature: 0.7});
+            break;
+        case 'Anthropic':
+            llm = new ChatAnthropic({apiKey, model: aiModel, temperature: 0.7});
+            break;
+        default:
+            throw new Error(`Unsupported AI provider: ${aiProvider}`);
+        }
+        return llm;
+    }
+    catch (e) {
+        return null;
+    }
+}
 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)
@@ -207,7 +235,7 @@ async function executeTool(action, params, user, allModels) {
  * soit en lançant la boucle de raisonnement de l'IA.
  * @param {string} message - Le message de l'utilisateur.
  * @param {Array} history - L'historique de la conversation.
- * @param {string} provider - Le fournisseur d'IA ('openai' ou 'google').
+ * @param {string} provider - Le fournisseur d'IA ('OpenAI' ou 'google').
  * @param {object} context - Contexte additionnel.
  * @param {object} user - L'objet utilisateur.
  * @param {object} confirmedAction - Une action pré-approuvée par l'utilisateur.
@@ -239,30 +267,17 @@ async function handleChatRequest(message, history, provider, context, user, conf
     // --- INITIALISATION DE L'IA ---
     let llm;
     try {
-        const p = provider || 'openai';
-        const providers = {"openai": "OPENAI_API_KEY", "google": "GOOGLE_API_KEY"};
-        const envKeyName = providers[p];
+        const p = provider || 'OpenAI';
+        const envKeyName = providers[p].key;
         if (!envKeyName) return {success: false, message: `Fournisseur IA non supporté : ${p}`};
 
         const envCollection = await getCollectionForUser(user);
         const userEnvVar = await envCollection.findOne({_model: 'env', name: envKeyName, _user: user.username});
         const apiKey = userEnvVar?.value || process.env[envKeyName];
 
-        if (!apiKey) return {success: false, message: `Clé API pour ${provider} (${envKeyName}) non trouvée.`};
-
-        llm = p === 'openai'
-            ? new ChatOpenAI({
-                apiKey,
-                modelName: "gpt-4o-mini",
-                temperature: 0.2,
-                response_format: {"type": "json_object"}
-            })
-            : new ChatGoogleGenerativeAI({
-                apiKey,
-                modelName: "gemini-1.5-pro-latest",
-                temperature: 0.2,
-                response_format: {"type": "json_object"}
-            });
+        if (!apiKey) return {success: false, message: `Clé API pour ${p} (${envKeyName}) non trouvée.`};
+
+        llm = getAIProvider(p, providers[p]?.defaultModel, apiKey);
     } catch (initError) {
         logger.error(`[Assistant] Erreur d'initialisation du client IA: ${initError.message}`);
         return {success: false, message: `Erreur d'initialisation du client IA: ${initError.message}`};
@@ -371,7 +386,7 @@ async function executeConfirmedAction(action, params, user) {
 export async function onInit(engine) {
     logger = engine.getComponent(Logger);
 
-    const {middlewareAuthenticator, userInitiator} = await import('./user.js');
+    const {middlewareAuthenticator, userInitiator} = await import('../user.js');
 
     engine.post('/api/assistant/chat', [middlewareAuthenticator, userInitiator, assistantGlobalLimiter, generateLimiter], async (req, res) => {
         // On récupère TOUTES les propriétés du body, y compris l'action confirmée

package/src/modules/assistant/constants.js

@@ -0,0 +1,16 @@
+
+export const providers = {
+    "OpenAI" : {
+        key:"OPENAI_API_KEY",
+        defaultModel: 'gpt-3.5-turbo'
+    },
+    "Google": {
+        key:"GOOGLE_API_KEY"
+    },
+    "DeepSeek": {
+        key: "DEEPSEEK_API_KEY"
+    },
+    "Anthropic": {
+        key:"ANTHROPIC_API_KEY"
+    }
+};

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

@@ -0,0 +1,304 @@
+import {isPlainObject} from "../../core.js";
+import {getCollection, getCollectionForUser, isObjectId, ObjectId} from "../mongodb.js";
+import {getModel, handleDemoInitialization} from "./data.js";
+import { Event} from "../../events.js"
+import {Logger} from "../../gameObject.js";
+import {hasPermission, middlewareAuthenticator, userInitiator} from "../user.js";
+import {isLocalUser} from "../../data.js";
+
+let logger;
+/**
+ * Compare deux valeurs de manière récursive. Gère les ObjectId, les objets, les tableaux et les primitives.
+ * @param {*} a - Première valeur.
+ * @param {*} b - Deuxième valeur.
+ * @returns {boolean} - True si les valeurs sont sémantiquement égales.
+ */
+function isEqual(a, b) {
+    if (a === b) return true;
+    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+    if (a instanceof ObjectId && b instanceof ObjectId) return a.toString() === b.toString();
+    if (!a || !b || (typeof a !== 'object' && typeof b !== 'object')) return a === b;
+    if (a.constructor !== b.constructor) return false;
+
+    if (Array.isArray(a)) {
+        if (a.length !== b.length) return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!isEqual(a[i], b[i])) return false;
+        }
+        return true;
+    }
+
+    if (isPlainObject(a)) {
+        const keys = Object.keys(a);
+        if (keys.length !== Object.keys(b).length) return false;
+        for (const key of keys) {
+            if (!Object.prototype.hasOwnProperty.call(b, key) || !isEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    return false;
+}
+/**
+ * Calcule la différence entre deux documents pour les champs historisés.
+ * @param {object} beforeDoc - Le document avant modification.
+ * @param {object} afterDoc - Le document après modification.
+ * @param {string[]} historizedFields - La liste des champs à surveiller.
+ * @returns {object} - Un objet contenant les changements, ou un objet vide si rien n'a changé.
+ */
+function calculateDiff(beforeDoc, afterDoc, historizedFields) {
+    const changes = {};
+    for (const fieldName of historizedFields) {
+        const beforeValue = beforeDoc[fieldName];
+        const afterValue = afterDoc[fieldName];
+
+        if (!isEqual(beforeValue, afterValue)) {
+            changes[fieldName] = {
+                from: beforeValue,
+                to: afterValue
+            };
+        }
+    }
+    // Retourne null si aucun changement n'a été détecté, ce qui est plus facile à vérifier qu'un objet vide.
+    return Object.keys(changes).length > 0 ? changes : null;
+}
+
+
+/**
+ * @route   GET /api/data/history/:modelName/:recordId
+ * @desc    Récupère l'historique d'un enregistrement spécifique pour le frontend.
+ * @access  Private (géré par middlewareAuthenticator)
+ */
+export async function handleGetHistoryRequest(req, res) {
+    const { modelName, recordId } = req.params;
+    const user = req.me; // Le middleware d'authentification attache l'utilisateur à req.me
+
+    try {
+        // 1. Vérification des permissions (similaire à searchData)
+        if (user && user.username !== 'demo' && isLocalUser(user) && (
+            !await hasPermission(["API_ADMIN", "API_SEARCH_DATA", "API_SEARCH_DATA_"+modelName], user) ||
+            await hasPermission(["API_SEARCH_DATA_NOT_"+modelName], user))) {
+            return res.status(403).json({ success: false, error: i18n.t('api.permission.searchData') });
+        }
+
+        // 2. Validation des entrées
+        if (!modelName || !recordId || !isObjectId(recordId)) {
+            return res.status(400).json({ success: false, error: "Invalid model name or record ID." });
+        }
+
+        // 3. Récupération des données depuis la collection 'history'
+        const historyCollection = getCollection('history');
+        const historyData = await historyCollection.find({
+            documentId: new ObjectId(recordId),
+            model: modelName
+        }).sort({ version: -1 }).toArray(); // Trier du plus récent au plus ancien
+
+        // 4. Transformation des données pour correspondre au format attendu par le composant HistoryDialog.jsx
+        const opMap = {
+            create: 'i',
+            update: 'u',
+            delete: 'd'
+        };
+
+        const transformedHistory = historyData.map(entry => {
+            const { documentId, version, operation, timestamp, user: historyUser, snapshot, changes, ...rest } = entry;
+
+            // Le contenu est soit un snapshot complet, soit un objet de changements
+            const dataPayload = snapshot || changes || {};
+
+            // On exclut les métadonnées du payload pour ne pas les dupliquer
+            const { _id: originalDocId, _model, _user, _hash, ...payloadFields } = dataPayload;
+
+            return {
+                ...rest, // Conserve l'_id du document d'historique lui-même
+                _rid: documentId,
+                _v: version,
+                _op: opMap[operation] || operation, // 'create' -> 'i', 'update' -> 'u', etc.
+                _updatedAt: timestamp,
+                _user: historyUser?.username,
+                ...payloadFields // Étale les champs du document (snapshot ou changes)
+            };
+        });
+
+        res.json({ success: true, data: transformedHistory });
+
+    } catch (error) {
+        logger.error(`[handleGetHistoryRequest] Error fetching history for model ${modelName}, record ${recordId}:`, error);
+        res.status(500).json({
+            success: false,
+            error: 'An internal server error occurred while fetching history.'
+        });
+    }
+}
+
+
+/**
+ * Initialise les écouteurs d'événements pour le module d'historique.
+ * @param {object} engine - L'instance du moteur.
+ */
+export function onInit(engine) {
+    logger = engine.getComponent(Logger);
+
+    engine.get('/api/data/history/:modelName/:recordId', [middlewareAuthenticator, userInitiator], handleGetHistoryRequest);
+
+    // --- Écouteur pour la CRÉATION de données (Version 1 - Snapshot) ---
+    Event.Listen("OnDataAdded", async (engine, { modelName, insertedIds, 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) {
+                await historyCollection.insertOne({
+                    documentId: doc._id,
+                    model: modelName,
+                    timestamp: new Date(),
+                    user: { _id: user._id, username: user.username },
+                    version: 1,
+                    operation: 'create',
+                    snapshot: doc // Pour la création, on stocke un snapshot complet
+                });
+                logger.debug(`History v1 (create) created for ${modelName} document ${doc._id}`);
+            }
+        } catch (error) {
+            logger.error("History Module (OnDataAdded) Error:", error);
+        }
+    }, "event", "system");
+
+    // --- Écouteur pour la MODIFICATION de données (Versions > 1 - Diff) ---
+    Event.Listen("OnDataEdited", async (engine, { modelName, user, before, after }) => {
+        try {
+            const model = await getModel(modelName, user);
+            if (!model?.history?.enabled) return;
+
+            // Détermine les champs à historiser. Si non spécifié, tous les champs le sont.
+            const historizedFields = model.history.fields
+                ? Object.keys(model.history.fields).filter(f => model.history.fields[f] === true)
+                : model.fields.map(f => f.name);
+
+            if (historizedFields.length === 0) return; // Pas de champs à suivre
+
+            const historyCollection = getCollection('history');
+
+            for (const afterDoc of after) {
+                const beforeDoc = before.find(b => b._id.toString() === afterDoc._id.toString());
+                if (!beforeDoc) {
+                    logger.warn(`History Module: Could not find 'before' state for document ${afterDoc._id}. Skipping history record.`);
+                    continue;
+                }
+
+                const changes = calculateDiff(beforeDoc, afterDoc, historizedFields);
+
+                // S'il n'y a aucun changement sur les champs surveillés, on ne crée pas d'entrée.
+                if (!changes) {
+                    continue;
+                }
+
+                // Récupérer la dernière version pour incrémenter
+                const lastVersionDoc = await historyCollection.findOne({ documentId: afterDoc._id }, { sort: { version: -1 } });
+                const newVersion = lastVersionDoc ? lastVersionDoc.version + 1 : 2; // v1 est la création
+
+                await historyCollection.insertOne({
+                    documentId: afterDoc._id,
+                    model: modelName,
+                    timestamp: new Date(),
+                    user: { _id: user._id, username: user.username },
+                    version: newVersion,
+                    operation: 'update',
+                    changes: changes // On stocke uniquement les différences
+                });
+                logger.debug(`History v${newVersion} (update) created for ${modelName} document ${afterDoc._id}`);
+            }
+        } catch (error) {
+            logger.error("History Module (OnDataEdited) Error:", error);
+        }
+    }, "event", "system");
+
+    // --- Écouteur pour la SUPPRESSION de données (Snapshot final) ---
+    Event.Listen("OnDataDeleted", async (engine, { modelName, user, before }) => {
+        // 'before' est un tableau des documents complets juste avant leur suppression.
+        try {
+            const model = await getModel(modelName, user);
+            if (!model?.history?.enabled) return;
+
+            const historyCollection = getCollection('history');
+
+            for (const deletedDoc of before) {
+                // Récupérer la dernière version pour incrémenter
+                const lastVersionDoc = await historyCollection.findOne({ documentId: deletedDoc._id }, { sort: { version: -1 } });
+                // Si aucune version n'existe, c'est peut-être un cas où l'historique a été activé après la création.
+                // On commence à 1, sinon on incrémente.
+                const newVersion = lastVersionDoc ? lastVersionDoc.version + 1 : 1;
+
+                await historyCollection.insertOne({
+                    documentId: deletedDoc._id,
+                    model: modelName,
+                    timestamp: new Date(),
+                    user: { _id: user._id, username: user.username },
+                    version: newVersion,
+                    operation: 'delete',
+                    // On stocke un snapshot final du document supprimé pour audit ou restauration.
+                    snapshot: deletedDoc
+                });
+                logger.debug(`History v${newVersion} (delete) created for ${modelName} document ${deletedDoc._id}`);
+            }
+        } catch (error) {
+            logger.error("History Module (OnDataDeleted) Error:", error);
+        }
+    }, "event", "system");
+
+    logger.info("History module initialized and listening for data events.");
+}
+
+
+/**
+ * Purge (supprime définitivement) des documents et tout leur historique associé.
+ * C'est une opération destructive à utiliser avec précaution.
+ * @param {object} user - L'utilisateur effectuant l'opération (pour les permissions).
+ * @param {string} modelName - Le nom du modèle concerné.
+ * @param {object} filter - Le filtre MongoDB pour trouver les documents à purger.
+ * @returns {Promise<{success: boolean, purgedCount: number, historyPurgedCount: number, error?: string}>}
+ */
+export async function purgeData(user, modelName = null, filter=null) {
+    const logger = new Logger("purgeData");
+    try {
+        const dataCollection = await getCollectionForUser(user);
+        const historyCollection = getCollection('history');
+
+        let m = modelName || { _model: modelName };
+        const f= filter || { _user: user.username };
+        // 1. Trouver les documents à purger pour récupérer leurs IDs
+        const docsToPurge = await dataCollection.find({ ...m, ...f }).project({ _id: 1 }).toArray();
+        if (docsToPurge.length === 0) {
+            return { success: true, purgedCount: 0, historyPurgedCount: 0 };
+        }
+        const docIdsToPurge = docsToPurge.map(d => d._id);
+
+        // 2. Purger l'historique associé à ces documents
+        const historyResult = await historyCollection.deleteMany({ documentId: { $in: docIdsToPurge } });
+
+        // 3. Purger les documents eux-mêmes
+        const dataResult = await dataCollection.deleteMany({ _id: { $in: docIdsToPurge } });
+
+        logger.info(`Purged ${dataResult.deletedCount} documents and ${historyResult.deletedCount} history entries for model '${modelName}'.`);
+
+        // On pourrait aussi émettre un événement "OnDataPurged" ici si nécessaire
+        await Event.Trigger("OnDataPurged", { user, modelName, purgedIds: docIdsToPurge });
+
+        return {
+            success: true,
+            purgedCount: dataResult.deletedCount,
+            historyPurgedCount: historyResult.deletedCount
+        };
+
+    } catch (error) {
+        logger.error(`Error during data purge for model '${modelName}':`, error);
+        return { success: false, purgedCount: 0, historyPurgedCount: 0, error: error.message };
+    }
+}