data-primals-engine 1.0.0

package/src/modules/assistant.js

@@ -0,0 +1,296 @@
+// server/src/modules/assistant.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.js";
+import { getDataAsString } from "../data.js";
+import i18n from "../../../data-primals-engine/src/i18n.js";
+import {generateLimiter} from "./user.js";
+import rateLimit from "express-rate-limit";
+
+let logger = 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)
+    standardHeaders: true, // Active les en-têtes standard `RateLimit-*`
+    legacyHeaders: false, // Désactive les anciens en-têtes `X-RateLimit-*`
+    message: { success: false, message: "Trop de requêtes globales envoyées à l'assistant. Veuillez réessayer plus tard." },
+    skip: (req) => {
+        return !!req.body?.confirmedAction;
+    }
+});
+
+const createSystemPrompt = (modelDefs, conditionBuilderExample) =>`
+Tu es "Prior", un assistant expert en analyse de données pour la plateforme data.primals.net.
+Ta mission est d'aider l'utilisateur en répondant à ses questions sur ses données.
+
+STRICTEMENT INTERDIT :
+- DE FAIRE DES COMMENTAIRES TEXTUELS 
+- D'EXPLIQUER CE QUE TU VAS FAIRE
+- D'UTILISER DU TEXTE LIBRE SOUS AUCUNE FORME
+
+FORMAT DE RÉPONSE OBLIGATOIRE :
+Un SEUL objet JSON valide contenant exactement 2 champs :
+1. "action" (string) 
+2. "params" (object)
+
+Tu as accès aux outils suivants. Tu ne dois utiliser QUE ces outils.
+
+1.  **search**: Pour chercher des informations dans les données de l'utilisateur.
+    - Utilisation: \`{ "action": "search", "params": { "model": "nomDuModele", "filter": $FILTER, "limit": 10 } }\`
+
+2.  **post**: Pour créer une nouvelle donnée.
+    - Utilisation: \`{ "action": "post", "params": { "model": "nomDuModele", "data": $DATA } }\`
+
+3.  **update**: Pour mettre à jour des données existantes.
+    - Utilisation: \`{ "action": "update", "params": { "model": "nomDuModele", "filter": $FILTER, "data": $DATA } }\` filter est très pratique pour mettre à jour des données ciblées en une seule passe.
+
+4.  **delete**: Pour supprimer des données.
+    - Utilisation: \`{ "action": "delete", "params": { "model": "nomDuModele", "filter": $FILTER } }\`
+
+5.  **displayMessage**: Pour répondre directement à l'utilisateur. N'utilise cette action QUE lorsque tu as toutes les informations nécessaires pour formuler une réponse finale.
+    - Utilisation: \`{ "action": "displayMessage", "params": { "message": "Ta réponse textuelle." } }\`
+
+La spécification suivante peut t'aider à construire les filtres) est la suivante :
+utilise une chaine de caracteres lorsque le type de champ est : code, string, string_t , password, url, phone, email, richtext
+utilise une structure { "iso2langcode":"content..." } pour le champ multi-traductions richtext_t
+utilise un booléen pour : boolean
+utilise un nombre pour number
+utilise une date au format ISO String pour les types de champ : date, datetime,
+utilise les valeurs de l'attribut items pour les champs de type : enum 
+utilise un tableau de données brutes pour les champs de type : array
+utilise un _id nécessairement pour remplir les champs relation multiple=false
+utilise un tableau d'_ids pour remplir les champs relation multiple=true
+utilise la valeur en héxadecimal, ex: '#FF0000' pour les champs de type : color 
+utilise les valeurs de cron standard '* * * * * *' pour : cronSchedule 
+
+PROCESSUS DE RAISONNEMENT:
+1. L'utilisateur pose une question.
+2. Tu analyses la question et choisis l'outil approprié.
+3. Tu réponds IMMÉDIATEMENT avec l'objet JSON correspondant SANS COMMENTAIRE.
+
+CONTEXTE ACTUEL:
+- L'utilisateur a accès aux modèles de données suivants et ne peut utiliser les filtres que sur les champs associés:
+${modelDefs.map(m => `  - Modèle "${m.name}":\n    Champs: ${JSON.stringify(m.fields.map(f => ({ name: f.name, type: f.type, hint: f.hint })), null, 2)}`).join('\n')}
+- Le format pour les filtres ($FILTER) est : ${conditionBuilderExample}
+- Le format de $DATA est { modelFieldName: "value", otherModelFieldName: { subObj : true } }
+
+
+Règles ABSOLUES:
+- UNE SEULE COMMANDE JSON PAR RÉPONSE
+- AUCUN TEXTE HORS DU JSON
+- SI TU N'APPLIQUES PAS CES RÈGLES, LE SYSTÈME TE DÉSACTIVERA
+
+Exemple de réponse CORRECTE :
+\`\`\`
+json
+{
+    "action" : "search",
+    "params" : {
+        "model": "request", "limit" : 10, "sort" : "_id:DESC"
+    }
+}
+\`\`\`
+
+Exemple de réponse INCORRECTE (INTERDIT) :
+"Je vais d'abord rechercher ces requêtes. Voici la commande que je vais exécuter..."`;
+
+
+/**
+ * Gère la requête de chat, soit en exécutant une action confirmée,
+ * soit en lançant la boucle de raisonnement de l'IA.
+ */
+async function handleChatRequest(message, history, provider, context, user, confirmedAction) {
+
+    // --- GESTION D'UNE ACTION CONFIRMÉE ---
+    if (confirmedAction && confirmedAction.action) {
+        try {
+            const result = await executeConfirmedAction(confirmedAction.action, confirmedAction.params, user);
+            let successMessage = i18n.t('assistant.actionSuccess', "Action exécutée avec succès.");
+            if (result.insertedIds) successMessage = i18n.t('assistant.itemCreated', `Élément créé avec l'ID: {{id}}.`, { id: result.insertedIds.join(', ') });
+            if (result.modifiedCount) successMessage = i18n.t('assistant.itemsUpdated', `{{count}} élément(s) mis à jour.`, { count: result.modifiedCount });
+            if (result.deletedCount) successMessage = i18n.t('assistant.itemsDeleted', `{{count}} élément(s) supprimés.`, { count: result.deletedCount });
+
+            return { success: true, displayMessage: successMessage };
+        } catch (error) {
+            logger.error(`[Assistant] Erreur lors de l'exécution de l'action confirmée: ${error.message}`, error.stack);
+            return { success: false, displayMessage: i18n.t('error', `Erreur : {{message}}`, { message: error.message }) };
+        }
+    }
+    // --- FIN DE LA GESTION DE CONFIRMATION ---
+
+    const { modelName } = context;
+
+    // --- Étape 1: Initialisation de l'IA ---
+    let apiKey;
+    let p = provider || 'openai';
+    const providers = { "openai": "OPENAI_API_KEY", "google": "GOOGLE_API_KEY" };
+    const envKeyName = providers[p];
+    if (!envKeyName) return { success: false, message: `Fournisseur IA non supporté : ${p}` };
+
+    const envCollection = getCollectionForUser(user);
+    const userEnvVar = await envCollection.findOne({ _model: 'env', name: envKeyName, _user: user.username });
+    apiKey = userEnvVar?.value || process.env[envKeyName];
+
+    if (!apiKey) return { success: false, message: `Clé API pour ${provider} (${envKeyName}) non trouvée.` };
+
+    let llm;
+    try {
+        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" } });
+    } catch (initError) {
+        return { success: false, message: `Initialisation du client IA pour ${p}: ${initError.message}` };
+    }
+
+    // --- Étape 2: Préparation du contexte pour l'IA ---
+    const allModels = await modelsCollection.find({ $or: [{ _user: { $exists: false } }, { _user: user.username }] }).toArray();
+    const relevantModelNames = new Set([modelName, 'alert', 'kpi', "dashboard", "request", "translation"]);
+    const modelDefs = allModels.filter(m => relevantModelNames.has(m.name));
+
+    const conditionBuilderExample = JSON.stringify({ "$and": [{ "$eq": ["$fieldName", "value"] }] }, null, 2);
+    const systemPrompt = createSystemPrompt(modelDefs, conditionBuilderExample);
+
+    const conversationHistory = history
+        .filter(msg => !(msg.from === 'bot' && msg.text.startsWith(i18n.t('assistant.welcome'))))
+        .map(msg => new (msg.from === 'user' ? HumanMessage : SystemMessage)(msg.text));
+
+    conversationHistory.unshift(new SystemMessage(systemPrompt));
+    conversationHistory.push(new HumanMessage(message));
+
+    const maxTurns = 5;
+
+    // --- Étape 3: La boucle de raisonnement ---
+    for (let i = 0; i < maxTurns; i++) {
+        logger.debug(`[Assistant] Tour de boucle ${i + 1}. Invocation de l'IA...`);
+
+        const response = await llm.invoke(conversationHistory);
+        const llmOutput = response.content;
+
+        let parsedResponse;
+        try {
+            parsedResponse = JSON.parse(llmOutput);
+            if (!parsedResponse.action || !parsedResponse.params) {
+                throw new Error("Format de réponse invalide.");
+            }
+        } catch (parseError) {
+            // Si ce n'est pas du JSON valide, on nettoie et affiche
+            const cleanedOutput = llmOutput.replace(/\{(?:[^{}]|(?:\{[^{}]*\}))*\}/g, '').trim();
+            return {
+                success: true,
+                displayMessage: cleanedOutput || i18n.t('assistant.invalidResponse', "Réponse non valide.")
+            };
+        }
+
+// Exécution IMMÉDIATE des actions sans confirmation (sauf pour post/update/delete)
+        switch (parsedResponse.action) {
+            case 'search': {
+                const searchResult = await searchData({
+                    user,
+                    query: {
+                        model: parsedResponse.params.model,
+                        filter: parsedResponse.params.filter,
+                        limit: parsedResponse.params.limit || 10
+                    }
+                });
+
+                const resultString = searchResult.data.length > 0
+                    ? i18n.t('assistant.searchResults', "Voici les résultats :") +
+                    searchResult.data.map(item =>
+                        `\n- ${getDataAsString(allModels.find(m => m.name === parsedResponse.params.model), item, i18n.t, allModels, true)}`
+                    ).join('')
+                    : i18n.t('assistant.noResults', "Aucun résultat trouvé.");
+
+                return { success: true, displayMessage: resultString };
+            }
+
+            case 'displayMessage':
+                return { success: true, displayMessage: parsedResponse.params.message };
+
+            case 'code':
+                return { success: true, displayMessage: "```json\n" + JSON.stringify(parsedResponse.params.message, null, 2) + "\n```" };
+
+            case 'post':
+            case 'update':
+            case 'delete':
+                return {
+                    success: true,
+                    displayMessage: i18n.t('assistant.confirmAction', `Je vais exécuter : ${parsedResponse.action}. Confirmez-vous ?`),
+                    confirmationRequest: parsedResponse
+                };
+
+            default:
+                return {
+                    success: true,
+                    displayMessage: i18n.t('assistant.unknownAction', "Commande non reconnue.")
+                };
+        }
+    }
+
+    logger.warn("[Assistant] La boucle a atteint le nombre maximum de tours sans réponse.");
+    return { success: true, displayMessage: i18n.t('assistant.loopTimeout', "Désolé, je n'ai pas réussi à terminer ma pensée. Pouvez-vous reformuler votre demande ?"), actions: [] };
+}
+
+/**
+ * Exécute une action de modification (post, update, delete) après confirmation de l'utilisateur.
+ * @param {string} action - L'action à exécuter ('post', 'update', 'delete').
+ * @param {object} params - Les paramètres de l'action.
+ * @param {object} user - L'objet utilisateur.
+ * @returns {Promise<object>} - Le résultat de l'opération de base de données.
+ */
+async function executeConfirmedAction(action, params, user) {
+    logger.info(`[Assistant] Exécution de l'action confirmée par l'utilisateur: ${action}`);
+    switch (action) {
+        case 'post':
+            // Note : on passe false pour ne pas redéclencher de workflow ici
+            return await insertData(params.model, params.data, {}, user, false, false);
+        case 'update':
+            return await patchData(params.model, params.filter, params.data, {}, user);
+        case 'delete':
+            // Le modèle est dans les params, pas besoin de le passer en argument sparé
+            return await deleteData(params.model, [], params.filter, user);
+        default:
+            throw new Error(`Action confirmée non supportée: ${action}`);
+    }
+}
+
+
+export async function onInit(engine) {
+    logger = engine.getComponent(Logger);
+
+    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
+        const {message, history, provider, context, confirmedAction} = req.body;
+
+        // La validation ne s'applique que s'il n'y a pas d'action confirmée
+        if (!confirmedAction) {
+            if (typeof (message) !== 'string' || !message.trim()) {
+                return res.status(400).json({
+                    success: false,
+                    message: i18n.t('api.validate.requiredFieldString', "Le champ '{{0}}' est requis et doit être une chaîne de caractères.", ["message"])
+                });
+            }
+            if (message.length > 4096) {
+                return res.status(400).json({
+                    success: false,
+                    message: 'Le message ne doit pas dépasser 4096 caractères.'
+                });
+            }
+        }
+
+        try {
+            const result = await handleChatRequest(message, history, provider, context, req.me, confirmedAction);
+            res.json(result);
+        } catch (error) {
+            logger.error(`[Endpoint /api/assistant/chat] Erreur inattendue: ${error.message}`, error.stack);
+            res.status(500).json({success: false, message: "Une erreur interne est survenue."});
+        }
+    });
+    logger.info("Module 'assistant' initialisé et endpoint '/api/assistant/chat' enregistré.");
+}

package/src/modules/bucket.js

@@ -0,0 +1,233 @@
+import process from "node:process";
+import AWS from "aws-sdk";
+import fs from "node:fs";
+import path from "node:path";
+import {decryptValue, encryptValue} from "../data.js";
+import {MongoClient} from "../engine.js";
+import {loadFromDump, validateRestoreRequest} from "./data.js";
+import {Logger} from "../gameObject.js";
+import {middlewareAuthenticator, myFreePremiumAnonymousLimiter, userInitiator} from "./user.js";
+import {awsDefaultConfig, maxBytesPerSecondThrottleData} from "../constants.js";
+import crypto from "node:crypto";
+import i18n from "../../../data-primals-engine/src/i18n.js";
+import {sendEmail} from "../email.js";
+import {throttleMiddleware} from "../middlewares/throttle.js";
+
+const restoreRequests = {};
+
+export const requestRestore = async (user, lang) => {
+    // On génère deux tokens uniques
+    const fullRestoreToken = crypto.randomBytes(32).toString('hex');
+    const modelsRestoreToken = crypto.randomBytes(32).toString('hex');
+    const expiration = new Date(Date.now() + 30 * 60 * 1000); // 30 minutes
+
+    restoreRequests[user?.username] = {
+        fullToken: fullRestoreToken,
+        modelsToken: modelsRestoreToken,
+        expiresAt: expiration,
+    };
+
+    i18n.changeLanguage(lang);
+
+    try {
+        // On utilise une nouvelle clé de traduction pour l'email
+        await sendEmail(user.email, {
+            title: i18n.t('email.backup.restoreRequest.subject'),
+            content: i18n.t('email.backup.restoreRequest.content', {
+                user: user?.username,
+                fullToken: fullRestoreToken,
+                modelsToken: modelsRestoreToken
+            })
+        });
+        return { message: 'Restore links sent to your email.' };
+    } catch (error) {
+        console.error('Error sending email:', error);
+        throw new Error('Error sending email.');
+    }
+};
+
+const getDefaultS3Config = () => {
+    return {
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY, // Utiliser la clé déchiffrée
+        region: process.env.AWS_REGION || awsDefaultConfig.region,
+        bucketName: process.env.AWS_BUCKET || awsDefaultConfig.bucketName,
+    };
+}
+const getS3Client = (s3Config) => {
+
+    const decryptedSecretAccessKey = decryptValue(s3Config.secretAccessKey);
+
+    const defaultConfig = getDefaultS3Config();
+
+    return new AWS.S3({
+        ...defaultConfig,
+        accessKeyId: s3Config.accessKeyId || defaultConfig.accessKeyId,
+        secretAccessKey: decryptedSecretAccessKey ? decryptedSecretAccessKey : defaultConfig.secretAccessKey,
+        region: s3Config.region || defaultConfig.region,
+        bucket: s3Config.bucketName || defaultConfig.bucketName
+    });
+};
+
+export const uploadToS3 = async (s3Config, filePath, remoteFilename) => {
+    const s3 = getS3Client(s3Config);
+    const fileContent = fs.readFileSync(filePath);
+    const bucketPath = s3Config.pathPrefix ? `${s3Config.pathPrefix.replace(/\/$/, "")}/${remoteFilename}` : remoteFilename;
+
+    const params = {
+        Bucket: s3Config.bucketName,
+        Key: bucketPath,
+        Body: fileContent,
+    };
+
+    try {
+        const data = await s3.upload(params).promise();
+        console.log(`File uploaded successfully to S3. ${data.Location}`);
+        return data;
+    } catch (err) {
+        console.error("Error uploading to S3:", err);
+        throw err;
+    }
+};
+
+export const listS3Backups = async (s3Config) => {
+    const s3 = getS3Client(s3Config);
+    const bucketPathPrefix = s3Config.pathPrefix ? `${s3Config.pathPrefix.replace(/\/$/, "")}/` : '';
+
+    const params = {
+        Bucket: s3Config.bucketName,
+        Prefix: bucketPathPrefix,
+    };
+
+    try {
+        const data = await s3.listObjectsV2(params).promise();
+        return data.Contents.map(item => ({
+            key: item.Key,
+            lastModified: item.LastModified,
+            size: item.Size,
+            // Tu peux extraire le nom du fichier et le timestamp de la clé si nécessaire
+            filename: path.basename(item.Key),
+            timestamp: parseInt(path.basename(item.Key).split('_').pop().split('.')[0], 10) || 0
+        })).sort((a, b) => b.timestamp - a.timestamp); // Trier par timestamp descendant
+    } catch (err) {
+        console.error("Error listing S3 backups:", err);
+        throw err;
+    }
+};
+
+export const downloadFromS3 = async (s3Config, s3FileKey, downloadPath) => {
+    const s3 = getS3Client(s3Config);
+    const params = {
+        Bucket: s3Config.bucketName,
+        Key: s3FileKey,
+    };
+
+    try {
+        const data = await s3.getObject(params).promise();
+        fs.writeFileSync(downloadPath, data.Body);
+        console.log(`File downloaded successfully from S3 to ${downloadPath}`);
+        return downloadPath;
+    } catch (err) {
+        console.error("Error downloading from S3:", err);
+        throw err;
+    }
+};
+
+const throttle = throttleMiddleware(maxBytesPerSecondThrottleData);
+
+let engine, logger;
+export async function onInit(defaultEngine) {
+    engine = defaultEngine;
+    logger = engine.getComponent(Logger);
+
+    engine.post('/api/backup/request-restore', [throttle, middlewareAuthenticator, userInitiator, myFreePremiumAnonymousLimiter], async (req, res) => {
+        const user = req.me; // Assuming you have user authentication middleware
+        if (!user) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+
+        try {
+            const result = await requestRestore(user);
+            res.json(result);
+        } catch (error) {
+            console.error('Error requesting restore:', error);
+            res.status(500).json({ error: error.message });
+        }
+    });
+    engine.get('/api/backup/restore', [throttle, middlewareAuthenticator, userInitiator], async (req, res) => {
+        const { token, username } = req.query;
+
+        if (!token || !username) {
+            return res.status(400).json({ error: 'Token and username are required.' });
+        }
+
+        const validationResult = validateRestoreRequest(username, token);
+
+        if (validationResult.error) {
+            return res.status(400).json({ error: validationResult.error });
+        }
+
+        try {
+            await loadFromDump({username});
+            res.json({ message: 'Backup restoration successful.' });
+            delete restoreRequests[username];
+        } catch (error) {
+            console.error('Error restoring backup:', error);
+            res.status(500).json({ error: 'Error restoring backup.' });
+        }
+    });
+
+    engine.post('/api/user/s3-config', [middlewareAuthenticator, userInitiator, myFreePremiumAnonymousLimiter], async (req, res) => {
+        const user = req.me;
+        const { bucketName, accessKeyId, secretAccessKey, region, pathPrefix } = req.body;
+
+        // Validation basique des entrées
+        if (!bucketName || !accessKeyId || !region) {
+            return res.status(400).json({ success: false, error: "Bucket name, Access Key ID, and Region are required." });
+        }
+        // Autres validations possibles (longueur, format de la région, etc.)
+
+        try {
+            const primalsDb = MongoClient.db("primals"); // Assure-toi que MongoClient est bien ton client MongoDB connecté
+            const usersCollection = primalsDb.collection("users");
+
+            const updateData = {
+                's3Config.bucketName': bucketName,
+                's3Config.accessKeyId': accessKeyId, // Stocké en clair (généralement acceptable)
+                's3Config.region': region,
+                's3Config.pathPrefix': pathPrefix || '', // S'assurer qu'il y a une valeur par défaut si vide
+            };
+
+            // Chiffrer et mettre à jour la clé secrète uniquement si elle est fournie
+            if (secretAccessKey) {
+                updateData['s3Config.secretAccessKey'] = encryptValue(secretAccessKey); // Chiffrer avant de stocker
+            } else {
+                // Si la clé secrète n'est pas fournie, on ne la modifie pas.
+                // Si tu veux permettre de la supprimer, il faudrait une logique explicite.
+                // Pour l'instant, on ne touche pas à s3Config.secretAccessKey si req.body.secretAccessKey est vide.
+            }
+
+            const result = await usersCollection.updateOne(
+                { username: user.username }, // ou user._id si c'est ce que tu utilises comme identifiant unique
+                { $set: updateData }
+            );
+
+            if (result.modifiedCount > 0 || result.matchedCount > 0) { // Succès même si rien n'a été modifié (déjà les bonnes valeurs)
+                logger.info(`S3 configuration updated for user ${user.username}`);
+                res.json({ success: true, message: "S3 configuration updated successfully." });
+            } else {
+                logger.warn(`S3 configuration update: User ${user.username} not found or no changes made.`);
+                // Si l'utilisateur n'est pas trouvé, c'est une erreur 404
+                const userExists = await usersCollection.findOne({ username: user.username });
+                if (!userExists) {
+                    return res.status(404).json({ success: false, error: "User not found." });
+                }
+                res.json({ success: true, message: "S3 configuration already up to date." });
+            }
+
+        } catch (error) {
+            logger.error(`Error updating S3 configuration for user ${user.username}:`, error);
+            res.status(500).json({ success: false, error: "An internal server error occurred while updating S3 configuration." });
+        }
+    });
+}