data-primals-engine 1.4.3 → 1.5.1

package/src/modules/assistant/assistant.js

@@ -12,6 +12,7 @@ import {maxAIReflectiveSteps} from "../../constants.js";
 import {providers} from "./constants.js";
 import {ChatDeepSeek} from "@langchain/deepseek";
 import {ChatAnthropic} from "@langchain/anthropic";
+import {Config} from "../../config.js";
 
 let logger = null;
 
@@ -52,14 +53,40 @@ export const assistantGlobalLimiter = rateLimit({
 });
 
 async function searchModels(query, user) {
-    if (!query) return [];
+    if (!query) return { main: [], related: [] };
     const searchRegex = new RegExp(query, 'i');
-    return await modelsCollection.find({
+    const mainModels = await modelsCollection.find({
         $or: [{ _user: user.username }, { _user: { $exists: false } }],
         $and: [{ $or: [{ name: { $regex: searchRegex } }, { description: { $regex: searchRegex } }] }]
     }, {
         projection: { name: 1, description: 1, fields: 1, _id: 0 }
     }).limit(10).toArray();
+
+    if (mainModels.length === 0) {
+        return { main: [], related: [] };
+    }
+
+    const relatedModelNames = new Set();
+    mainModels.forEach(model => {
+        model.fields.forEach(field => {
+            if (field.type === 'relation' && field.relation) {
+                relatedModelNames.add(field.relation);
+            }
+        });
+    });
+
+    const mainModelNames = new Set(mainModels.map(m => m.name));
+    const finalRelatedModelNames = [...relatedModelNames].filter(name => !mainModelNames.has(name));
+
+    let relatedModels = [];
+    if (finalRelatedModelNames.length > 0) {
+        relatedModels = await modelsCollection.find({
+            name: { $in: finalRelatedModelNames },
+            $or: [{ _user: user.username }, { _user: { $exists: false } }]
+        }, { projection: { name: 1, description: 1, fields: 1, _id: 0 } }).toArray();
+    }
+
+    return { main: mainModels, related: relatedModels };
 }
 
 const createSystemPrompt = (modelDefs, lang) => {
@@ -86,7 +113,7 @@ Tu as accès aux outils et actions suivants.
 
 OUTILS DE RAISONNEMENT INTERNE: (Utilisés pour collecter de l'information avant de décider de l'action finale)
 1.  **search_models**: Pour rechercher les modèles de données disponibles.
-    - Utilisation: { "action": "search_models", "params": { "query": "^regexToSearchFor$" } }
+    - Utilisation: { "action": "search_models", "params": { "query": "^regexToSearchFor$" } }. Il retourne aussi la structure des modèles directement liés.
 ====
 
 ACTIONS FINALES: (Actions qui terminent ta réflexion et renvoient un résultat à l'utilisateur)
@@ -118,9 +145,24 @@ ACTIONS FINALES: (Actions qui terminent ta réflexion et renvoient un résultat
         - \`yAxis\` (string): (Optionnel, sauf pour sum/avg/min/max) Le champ numérique à agréger du modèle.
         - \`filter\` (object): (Optionnel, filtre de la recherche, même écriture stricte que pour les filtres de recherche (voir plus bas pour les exemples) 
 
+7.  **generateHtmlView**: Pour créer une vue personnalisée en utilisant un template HTML.
+    - Utilisation: { "action": "generateHtmlView", "params": { ...config } }
+    - Le paramètre \`config\` doit contenir :
+        - \`title\` (string): Un titre pour la vue.
+        - \`model\` (string): Le nom du modèle de données à utiliser.
+        - \`template\` (string): Un template au format Handlebars.js. **RÈGLE CRITIQUE : N'utilise QUE les noms de champs (\`fieldName\`) exacts fournis par l'outil \`search_models\` pour le modèle principal ET pour ses modèles liés. N'invente JAMAIS de champs.**
+            Pour une liste, tu DOIS utiliser une boucle \`{{#each data}}...{{/each}}\`.
+            À l'intérieur d'une boucle, accède aux champs avec \`{{this.fieldName}}\`.
+            Pour les champs de type \`string_t\` ou \`richtext_t\`, accède à la traduction avec \`{{this.fieldName.value}}\`.
+            Les champs de type 'relation' sont automatiquement peuplés (hydratés), tu peux donc accéder à leurs propriétés directement (ex: \`{{this.relationField.name}}\` ou \`{{this.relationField.name.value}}\` si le champ 'name' de la relation est un 'string_t').
+        - \`css\` (string): (Optionnel) Du CSS riche et créatif pour styliser le template. N'hésite pas à utiliser des dégradés, des ombres, des animations et des polices de caractères pour un rendu professionnel et attrayant. **Règle absolue : tu dois préfixer TOUS tes sélecteurs avec \`#{{containerId}}\` pour isoler les styles.**
+        - \`filter\` (object): (Optionnel) Un filtre pour sélectionner les documents à afficher.
+        - \`limit\` (number): (Optionnel, défaut 10) Le nombre maximum de documents à récupérer.
+
 Voici le mémo pour assigner des valeurs aux champs des modèles,avec ces types de données : 
 utilise une chaine de caractère convertible en ObjectId (mongodb) lorsque le nom du champ est _id 
-utilise une chaine de caracteres lorsque le type de champ est : string, string_t , password, url, phone, email, richtext
+utilise une chaine de caracteres lorsque le type de champ est : string , password, url, phone, email, richtext
+utilise un objet { key: "trKey", value: "Translation"} lorsque le champ est string_t
 utilise un filtre en retour si le type de champ est code et language='json' et conditionBuilder=true
 utilise une chaine si c'est un type de champ code par défaut. 
 utilise une structure { "iso2langcode":"content..." } pour le champ multi-traductions richtext_t
@@ -134,13 +176,11 @@ 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:
-a- L'utilisateur pose une question, ou demande une action de ta part.
-b- Utilise l'outil **search_models** pour trouver le(s) modèle(s) qui correspondent à la question.
- Si tu as déjà fait la recherche dans la conversation, garde la définition initiale et n'effectue pas de recherche, va directement à l'étape c
-c- Une fois la réponse retournée et intégrée, tu devras utiliser les autres outils (search, post, etc.) dans la conversation pour satisfaire la question initiale, en utilisant les informations des modèles précédents (COMMANDE FINALE)
-Si tu n'as aucune commande à exécuter directement, réponds simplement à l'utilisateur avec "displayMessage".
-
+PROCESSUS DE RAISONNEMENT STRICT:
+a- L'utilisateur pose une question.
+b- **Étape 1 (Obligatoire):** Appelle l'outil \`search_models\` pour obtenir la structure EXACTE du modèle de données. C'est ta seule source de vérité pour les noms de champs.
+c- **Étape 2 (Obligatoire):** Analyse la réponse de \`search_models\` que le système t'a fournie.
+d- **Étape 3 (Commande Finale):** Construis ta commande finale (\`search\`, \`generateHtmlView\`, etc.). **Règle absolue :** Pour les filtres et les templates, tu ne dois utiliser QUE les noms de champs (\`name\`) et les types (\`type\`) que tu as lus dans la réponse de \`search_models\` à l'étape c. N'invente RIEN.
 CONTEXTE ACTUEL:
 - Date du jour de la conversation : ${dt}
 - La langue ISO à utiliser dans la conversation : ${lang}
@@ -182,6 +222,67 @@ COMMANDE FINALE :
   }
 }
 
+Question: Crée un tableau de bord des rôles et permissions avec un design sophistiqué.
+Ta réponse: { "action" : "search_models", "params": { "query": "role" } }
+COMMANDE FINALE :
+{
+  "action": "generateHtmlView",
+  "params": {
+    "title": "Matrice des Rôles et Permissions",
+    "model": "role",
+    "template": "<div class='roles-container'>{{#each data}}<div class='role-card'><div class='role-header'><span class='role-icon'>🛡️</span><h3>{{this.name.value}}</h3></div><ul class='permissions-list'>{{#each this.permissions}}<li data-tooltip-html='{{this.description}}'><span class='permission-name'>{{this.name.value}}</span></li>{{/each}}</ul></div>{{/each}}</div>",
+    "css": "#{{containerId}} .roles-container{display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:25px;padding:25px;font-family:'Poppins',sans-serif;background:#111827}#{{containerId}} .role-card{background:rgba(31,41,55,.5);border-radius:16px;padding:20px;position:relative;overflow:hidden;border:1px solid transparent;backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);transition:transform .3s ease,box-shadow .3s ease}#{{containerId}} .role-card::before{content:'';position:absolute;top:0;right:0;bottom:0;left:0;z-index:-1;margin:-1px;border-radius:inherit;background:conic-gradient(from 180deg at 50% 50%,#2a8af6 0deg,#a855f7 180deg,#f59e0b 360deg);animation:rotate-gradient 5s linear infinite}@keyframes rotate-gradient{0%{transform:rotate(0deg)}100%{transform:rotate(360deg)}}#{{containerId}} .role-card:hover{transform:translateY(-8px);box-shadow:0 20px 30px rgba(0,0,0,.2)}#{{containerId}} .role-header{display:flex;align-items:center;gap:12px;margin-bottom:15px;padding-bottom:10px;border-bottom:1px solid rgba(255,255,255,.1)}#{{containerId}} .role-header .role-icon{font-size:1.8em}#{{containerId}} .role-header h3{margin:0;font-size:1.4em;font-weight:600;color:#f9fafb}#{{containerId}} .permissions-list{list-style:none;padding:0;margin:0;max-height:200px;overflow-y:auto}#{{containerId}} .permissions-list::-webkit-scrollbar{width:6px}#{{containerId}} .permissions-list::-webkit-scrollbar-track{background:rgba(255,255,255,.05);border-radius:3px}#{{containerId}} .permissions-list::-webkit-scrollbar-thumb{background:#4f46e5;border-radius:3px}#{{containerId}} .permissions-list::-webkit-scrollbar-thumb:hover{background:#6366f1}#{{containerId}} .permissions-list li{padding:8px 12px;margin-bottom:6px;background:rgba(255,255,255,.05);border-radius:8px;color:#d1d5db;cursor:help;transition:background-color .2s ease;font-size:.95em}#{{containerId}} .permissions-list li:hover{background:rgba(79,70,229,.5);color:#fff}",
+    "filter": {},
+    "limit": 10
+  }
+}
+
+Question: Affiche une carte de visite stylisée pour le premier contact.
+Ta réponse: { "action" : "search_models", "params": { "query": "contact" } }
+COMMANDE FINALE :
+{
+  "action": "generateHtmlView",
+  "params": {
+    "title": "Carte de Visite",
+    "model": "contact",
+    "template": "<div class='card-container'><h3>{{this.firstName}} {{this.lastName}}</h3><p>{{this.email}}</p></div>",
+    "css": "#{{containerId}} .card-container { border: 1px solid #ccc; border-radius: 8px; padding: 16px; background-color: #f9f9f9; } #{{containerId}} h3 { margin-top: 0; color: #333; }",
+    "filter": {},
+    "limit": 1
+  }
+}
+
+Question: Montre-moi un catalogue des produits.
+Ta réponse: { "action" : "search_models", "params": { "query": "product" } }
+COMMANDE FINALE :
+{
+  "action": "generateHtmlView",
+  "params": {
+    "title": "Catalogue Produits",
+    "model": "product",
+    "template": "<div class='product-grid'>{{#each data}}<div class='product-card'><div class='product-image-container'><img src='{{this.image.0.url}}' alt='{{this.name.value}}' class='product-image'><span class='product-brand'>{{this.brand.name}}</span></div><div class='product-info'><h3 class='product-name'>{{this.name.value}}</h3><p class='product-category'>{{this.category.name.value}}</p><div class='product-footer'><span class='product-price'>{{this.price}} {{this.currency.symbol}}</span><button class='add-to-cart-btn'>Ajouter au panier</button></div></div></div>{{/each}}</div>",
+    "css": "#{{containerId}} .product-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(250px,1fr));gap:2rem;padding:2rem;font-family:'Lato',sans-serif;background-color:#f8f9fa}#{{containerId}} .product-card{background-color:#fff;border-radius:12px;box-shadow:0 4px 6px rgba(0,0,0,.05),0 1px 3px rgba(0,0,0,.05);overflow:hidden;transition:transform .3s ease,box-shadow .3s ease;display:flex;flex-direction:column}#{{containerId}} .product-card:hover{transform:translateY(-5px);box-shadow:0 12px 20px rgba(0,0,0,.08),0 3px 8px rgba(0,0,0,.06)}#{{containerId}} .product-image-container{position:relative;width:100%;padding-top:100%}#{{containerId}} .product-image{position:absolute;top:0;left:0;width:100%;height:100%;object-fit:cover}#{{containerId}} .product-brand{position:absolute;top:10px;right:10px;background-color:rgba(0,0,0,.6);color:#fff;padding:4px 8px;border-radius:6px;font-size:.8em;font-weight:700}#{{containerId}} .product-info{padding:15px;display:flex;flex-direction:column;flex-grow:1}#{{containerId}} .product-name{font-size:1.1em;font-weight:700;color:#343a40;margin:0 0 5px 0;line-height:1.3}#{{containerId}} .product-category{font-size:.85em;color:#6c757d;margin:0 0 15px 0;flex-grow:1}#{{containerId}} .product-footer{display:flex;justify-content:space-between;align-items:center;border-top:1px solid #e9ecef;padding-top:10px;margin-top:auto}#{{containerId}} .product-price{font-size:1.2em;font-weight:700;color:#007bff}#{{containerId}} .add-to-cart-btn{background-color:#007bff;color:#fff;border:none;padding:8px 12px;border-radius:8px;cursor:pointer;font-weight:600;transition:background-color .2s ease}#{{containerId}} .add-to-cart-btn:hover{background-color:#0056b3}",
+    "filter": {},
+    "limit": 12
+  }
+}
+
+Question: Affiche-moi les dernières requêtes API avec un design futuriste.
+Ta réponse: { "action" : "search_models", "params": { "query": "request" } }
+COMMANDE FINALE :
+{
+  "action": "generateHtmlView",
+  "params": {
+    "title": "Journal des Requêtes API",
+    "model": "request",
+    "template": "<div class=\"requests-grid\">{{#each data}}<div class=\"request-card status-{{this.status}}\"><div class=\"card-header\"><span class=\"method-badge method-{{this.method}}\">{{this.method}}</span><span class=\"status-code\" data-tooltip-html=\"Code de statut HTTP\">{{this.status}}</span></div><div class=\"card-body\"><p class=\"url\" data-tooltip-html=\"URL de la requête\">{{this.url}}</p></div><div class=\"card-footer\"><span class=\"latency\" data-tooltip-html=\"Latence de la réponse\">⏱️ {{this.latencyMs}} ms</span><span class=\"timestamp\" data-tooltip-html=\"Date et heure\">{{this.timestamp}}</span></div><div class=\"glow-effect\"></div></div>{{/each}}</div>",
+    "css": "#{{containerId}} .requests-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(300px,1fr));gap:20px;font-family:'Orbitron',sans-serif;padding:10px}#{{containerId}} .request-card{background:rgba(10,25,47,.8);border:1px solid #00aaff;border-radius:12px;padding:15px;position:relative;overflow:hidden;transition:transform .3s ease,box-shadow .3s ease;backdrop-filter:blur(5px);-webkit-backdrop-filter:blur(5px)}#{{containerId}} .request-card:hover{transform:translateY(-5px);box-shadow:0 10px 20px rgba(0,170,255,.3)}#{{containerId}} .glow-effect{position:absolute;top:0;left:0;width:100%;height:100%;background:radial-gradient(circle at 50% 0,rgba(0,170,255,.2),transparent 70%);animation:pulse 4s infinite ease-in-out;pointer-events:none}@keyframes pulse{0%,100%{opacity:.5}50%{opacity:1}}#{{containerId}} .card-header{display:flex;justify-content:space-between;align-items:center;margin-bottom:12px;border-bottom:1px solid rgba(0,170,255,.2);padding-bottom:8px}#{{containerId}} .method-badge{padding:4px 8px;border-radius:5px;font-weight:700;font-size:.9em;color:#fff;text-shadow:0 0 5px currentColor}#{{containerId}} .method-GET{background-color:#00aaff}#{{containerId}} .method-POST{background-color:#4caf50}#{{containerId}} .method-PUT{background-color:#ff9800}#{{containerId}} .method-DELETE{background-color:#f44336}#{{containerId}} .method-PATCH{background-color:#9c27b0}#{{containerId}} .status-code{font-size:1.2em;font-weight:700;color:#fff}#{{containerId}} .status-200 .status-code{color:#4caf50;text-shadow:0 0 8px #4caf50}#{{containerId}} .status-404 .status-code{color:#f44336;text-shadow:0 0 8px #f44336}#{{containerId}} .status-500 .status-code{color:#ff9800;text-shadow:0 0 8px #ff9800}#{{containerId}} .card-body .url{color:#e0e0e0;font-size:.95em;word-break:break-all;margin:0}#{{containerId}} .card-footer{display:flex;justify-content:space-between;align-items:center;margin-top:15px;font-size:.8em;color:#88a1b9}#{{containerId}} .latency,#{{containerId}} .timestamp{display:flex;align-items:center;gap:5px}",
+    "filter": {},
+    "sort": { "_id": -1 },
+    "limit": 12
+  }
+}
+
 Absolute rules:
 ====
 NEVER use the non-aggregated syntax of the MongoDB operators :
@@ -274,11 +375,17 @@ async function executeTool(action, params, user, allModels) {
             return resultString;
         }
         case 'search_models': {
-            const foundModels = await searchModels(params.query, user);
+            const { main: foundModels, related: relatedModels } = await searchModels(params.query, user);
 
             if (foundModels.length > 0) {
-                return "J'ai trouvé les modèles suivants qui pourraient correspondre : " +
+                let responseText = "J'ai trouvé les modèles suivants qui pourraient correspondre : " +
                         foundModels.map(m => `\n- Modèle "${m.name}": ${m.description || 'Pas de description.'}\n- Champs: ${m.fields.map(f => JSON.stringify(f, null, 2))}`).join('');
+
+                if (relatedModels.length > 0) {
+                    responseText += "\n\nPour votre information, voici la structure des modèles liés que vous pouvez utiliser dans les templates :";
+                    responseText += relatedModels.map(m => `\n- Modèle lié "${m.name}":\n- Champs: ${m.fields.map(f => JSON.stringify(f, null, 2))}`).join('');
+                }
+                return responseText;
             } else {
                 return "Je n'ai trouvé aucun modèle correspondant à votre recherche.";
             }
@@ -356,7 +463,8 @@ async function handleChatRequest(message, history, provider, context, user, conf
 
 
     // --- BOUCLE DE RAISONNEMENT ET D'EXÉCUTION D'OUTILS ---
-    for (let i = 0; i < maxAIReflectiveSteps; i++) {
+    const m = Config.Get('maxAIReflectiveSteps', maxAIReflectiveSteps);
+    for (let i = 0; i < m; i++) {
         logger.debug(`[Assistant] Tour de boucle ${i + 1}. Invocation de l'IA...`);
 
         const response = await llm.invoke(conversationHistory);
@@ -365,18 +473,25 @@ async function handleChatRequest(message, history, provider, context, user, conf
         // Parsing JSON robuste
         let parsedResponse;
         try {
+            // Tente d'extraire le JSON de la réponse, même s'il est entouré de texte.
+            const jsonRegex = /\{[\s\S]*\}/s; // 's' flag pour que '.' matche les nouvelles lignes
+            const match = llmOutput.match(jsonRegex);
 
-            parsedResponse = JSON.parse(llmOutput);
+            if (match && match[0]) {
+                // Si un JSON est trouvé, on tente de le parser
+                parsedResponse = JSON.parse(match[0]);
+            } else {
+                // Aucun JSON trouvé, c'est probablement une réponse textuelle simple.
+                return { success: true, displayMessage: llmOutput };
+            }
 
             if (!parsedResponse.action || !parsedResponse.params) {
                 throw new Error("Réponse JSON invalide: 'action' ou 'params' manquant.");
             }
         } catch (parseError) {
             logger.error(`[Assistant] Erreur de parsing de la réponse de l'IA: ${parseError.message}. Réponse brute: "${llmOutput}"`);
-            return {
-                success: true,
-                displayMessage: llmOutput || i18n.t('assistant.invalidResponse', "Désolé, je n'ai pas pu formuler une réponse correcte. Veuillez réessayer.")
-            };
+            // Si le parsing échoue, on renvoie le message brut de l'IA, qui est peut-être une réponse textuelle valide.
+            return { success: true, displayMessage: llmOutput };
         }
 
         logger.debug(`[Assistant] Action décidée par l'IA: ${parsedResponse.action}`, parsedResponse);
@@ -396,6 +511,23 @@ async function handleChatRequest(message, history, provider, context, user, conf
             return { success: true, chartConfig: params };
         }
 
+        // Action de génération de vue HTML
+        if (action === 'generateHtmlView') {
+            const viewData = await searchData({
+                model: params.model,
+                filter: params.filter,
+                limit: params.limit || 10,
+                depth: 2 // Pour avoir accès aux relations de premier niveau dans les templates
+            }, user);
+
+            if (viewData.data.length === 0) {
+                return { success: true, displayMessage: i18n.t('assistant.htmlView.noResult', "Je n'ai trouvé aucune donnée correspondante pour cette vue.") };
+            }
+
+            // On retourne la configuration de la vue ET les données au client.
+            return { success: true, htmlViewConfig: { ...params, data: viewData.data } };
+        }
+
         // NOUVEAU: Action de recherche à afficher, gérée par le front-end
         if (action === 'search') {
             const searchResult = await searchData({

package/src/modules/bucket.js

@@ -6,13 +6,14 @@ import {decryptValue, encryptValue} from "../data.js";
 import {loadFromDump, validateRestoreRequest} from "./data/index.js";
 import {Logger} from "../gameObject.js";
 import {middlewareAuthenticator, userInitiator} from "./user.js";
-import {awsDefaultConfig, maxBytesPerSecondThrottleData} from "../constants.js";
+import {awsDefaultConfig, getHost, maxBytesPerSecondThrottleData} from "../constants.js";
 import crypto from "node:crypto";
 import i18n from "../../src/i18n.js";
 import {sendEmail} from "../email.js";
 import {throttleMiddleware} from "../middlewares/throttle.js";
 import {getCollectionForUser} from "./mongodb.js";
 import {safeAssignObject} from "../core.js";
+import {Config} from "../config.js";
 
 const restoreRequests = {};
 
@@ -37,6 +38,7 @@ export const requestRestore = async (user, lang) => {
             content: i18n.t('email.backup.restoreRequest.content', {
                 user: user?.username,
                 fullToken: fullRestoreToken,
+                host: getHost(),
                 modelsToken: modelsRestoreToken
             })
         });
@@ -47,15 +49,6 @@ export const requestRestore = async (user, lang) => {
     }
 };
 
-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
-    };
-}
-
 /**
  * Récupère la configuration S3 depuis les variables d'environnement de l'utilisateur en base de données.
  * @param {object} user - L'objet utilisateur.
@@ -98,12 +91,16 @@ async function _getUserS3ConfigFromDb(user) {
  * @returns {Promise<object>} - L'objet de configuration S3 final.
  */
 export async function getUserS3Config(user) {
+
+    const adc = awsDefaultConfig;
+    const dc = Config.Get('awsDefaultConfig', {});
+
     // 1. Récupérer la configuration globale par défaut
     const defaultConfig = {
-        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-        region: process.env.AWS_REGION || awsDefaultConfig.region,
-        bucketName: process.env.AWS_BUCKET_NAME || awsDefaultConfig.bucketName
+        accessKeyId: dc.accessKeyId || process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: dc.secretAccessKey || process.env.AWS_SECRET_ACCESS_KEY,
+        region: dc.region || process.env.AWS_REGION || adc.region,
+        bucketName: dc.bucketName || process.env.AWS_BUCKET_NAME || adc.bucketName
     };
 
     // 2. Récupérer la configuration spécifique de l'utilisateur
@@ -243,13 +240,14 @@ export const getS3Stream = (s3Config, s3Key) => {
     return s3.getObject(params).createReadStream();
 };
 
-const throttle = throttleMiddleware(maxBytesPerSecondThrottleData);
-
 let engine, logger;
 export async function onInit(defaultEngine) {
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
 
+    const m = Config.Get('maxBytesPerSecondThrottleData', maxBytesPerSecondThrottleData);
+    const throttle = throttleMiddleware(m);
+
     const userMiddlewares = await engine.userProvider.getMiddlewares();
     engine.post('/api/backup/request-restore', [throttle, middlewareAuthenticator, userInitiator, ...userMiddlewares], async (req, res) => {
         const user = req.me; // Assuming you have user authentication middleware

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

@@ -153,7 +153,8 @@ export const loadFromDump = async (user, options = {}) => {
         }
 
         // --- EXÉCUTION DE MONGORESTORE ---
-        const restoreSourceDir = path.join(tmpRestoreDir, dbName);
+        const d = Config.Get('dbName', dbName);
+        const restoreSourceDir = path.join(tmpRestoreDir, d);
         if (!fs.existsSync(restoreSourceDir)) {
             throw new Error(`Restore source directory (${restoreSourceDir}) not found.`);
         }
@@ -161,15 +162,15 @@ export const loadFromDump = async (user, options = {}) => {
         let command;
         const args = [
             '--uri', dbUrl,
-            '--db', dbName
+            '--db', d
         ];
 
         if (modelsOnly) {
-            args.push('--nsInclude', `${dbName}.models`);
+            args.push('--nsInclude', `${d}.models`);
         } else {
             // mongorestore accepte plusieurs fois l'option --nsInclude
-            args.push('--nsInclude', `${dbName}.datas`);
-            args.push('--nsInclude', `${dbName}.models`);
+            args.push('--nsInclude', `${d}.datas`);
+            args.push('--nsInclude', `${d}.models`);
         }
         // Le répertoire source est le dernier argument
         args.push(restoreSourceDir);
@@ -242,6 +243,8 @@ export const dumpUserData = async (user) => {
         const backupFrequency = await engine.userProvider.getBackupFrequency(user);
         logger.info(`Fréquence de sauvegarde : ${backupFrequency}.`);
 
+
+        const d = Config.Get('dbName', dbName);
         const collections = await MongoDatabase.listCollections().toArray();
         for (const collection of collections) {
             const collsToBackup = [await getUserCollectionName(user), 'models'];
@@ -249,7 +252,7 @@ export const dumpUserData = async (user) => {
                 const query = {_user: user.username};
                 const args = [
                     '--uri', dbUrl,
-                    '--db', dbName,
+                    '--db', d,
                     '--out', localTempDumpDir,
                     '--collection', collection.name,
                     '--query', JSON.stringify(query)
@@ -258,9 +261,9 @@ export const dumpUserData = async (user) => {
                 await execFileAsync('mongodump', args);
             }
         }
-        const dumpSourceDir = path.join(localTempDumpDir, dbName);
+        const dumpSourceDir = path.join(localTempDumpDir, d);
         if (fs.existsSync(dumpSourceDir)) {
-            await tar.create({gzip: true, file: localArchivePath, C: localTempDumpDir}, [dbName]);
+            await tar.create({gzip: true, file: localArchivePath, C: localTempDumpDir}, [d]);
             logger.info(`Archive de sauvegarde locale créée : ${localArchivePath}`);
         } else {
             logger.warn(`Le répertoire de dump ${dumpSourceDir} était vide. Aucune archive n'a créée.`);

package/src/modules/data/data.core.js

@@ -1,93 +1,119 @@
-import NodeCache from "node-cache";
-import path from "node:path";
-import {Worker} from 'worker_threads';
-import {fileURLToPath} from "node:url";
-export const modelsCache = new NodeCache( { stdTTL: 100, checkperiod: 120 } );
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export const mongoDBWhitelist = [
-    "$$NOW", "$in", "$eq", "$gt", "$gte", "$in", "$lt", "$lte", "$ne", "$nin", "$type", "$size",
-    "$and", "$not", "$nor", "$or", "$regexMatch", "$find", "$elemMatch", "$filter", "$toString", "$toObjectId",
-    "$concat",
-    '$add', '$subtract', '$multiply', '$divide', '$mod', '$pow', "$sqrt",
-    "$rand",
-    "$abs", '$sin', '$cos', '$tan', '$asin', '$acos', '$atan',
-    "$toDate", "$toBool", "$toString", "$toInt", "$toDouble",
-    "$dateDiff", "$dateSubtract", "$dateAdd", "$dateToString",
-    '$year', '$month', '$week', '$dayOfMonth', '$dayOfWeek', '$dayOfYear', '$hour', '$minute', '$second', '$millisecond',
-    '$geoNear', '$regex', '$text', '$nearSphere','$geoWithin','$geoIntersects'
-];
-export let importJobs = {};
-
-
-/**
- * Exécute une tâche d'import/export (parsing, stringify) dans un worker thread.
- * @param {('parse-json'|'parse-csv'|'stringify-json')} action - L'action à effectuer.
- * @param {object} payload - Les données nécessaires pour l'action.
- * @returns {Promise<any>} - Une promesse qui se résout avec les données traitées.
- */
-export function runImportExportWorker(action, payload) {
-    return new Promise((resolve, reject) => {
-        const workerPath = path.resolve(process.cwd(), './src/workers/import-export-worker.js');
-        const worker = new Worker(workerPath);
-
-        worker.postMessage({ action, payload });
-
-        worker.on('message', (result) => {
-            if (result.success) {
-                resolve(result.data);
-            } else {
-                // Correction : On s'assure de toujours passer une chaîne de caractères à new Error()
-                const errorMessage = result.error || `Import/Export Worker failed with an unknown error. Action: ${action}.`;
-                reject(new Error(errorMessage));
-            }
-            worker.terminate();
-        });
-
-        worker.on('error', (err) => {
-            reject(err);
-            worker.terminate();
-        });
-
-        worker.on('exit', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Import/Export Worker stopped with exit code ${code}`));
-            }
-        });
-    });
-}
-/** Exécute une tâche de cryptographie dans un worker thread.
- * @param {('encrypt'|'decrypt'|'hash')} action - L'action à effectuer.
- * @param {object} payload - Les données nécessaires pour l'action.
- * @returns {Promise<any>} - Une promesse qui se résout avec le résultat (si pertinent).
- */
-export function runCryptoWorkerTask(action, payload) {
-    return new Promise((resolve, reject) => {
-        const workerPath = path.resolve(__dirname, '../../workers/crypto-worker.js');
-        const worker = new Worker(workerPath);
-
-        worker.postMessage({ action, payload });
-
-        worker.on('message', (result) => {
-            if (result.success) {
-                resolve(result.data); // Résout avec les données (ex: le hash) ou undefined si pas de retour
-            } else {
-                reject(new Error(result.error));
-            }
-            worker.terminate();
-        });
-
-        worker.on('error', (err) => {
-            reject(err);
-            worker.terminate();
-        });
-
-        worker.on('exit', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Crypto Worker stopped with exit code ${code}`));
-            }
-        });
-    });
+import NodeCache from "node-cache";
+import path from "node:path";
+import {Worker} from 'worker_threads';
+import {fileURLToPath} from "node:url";
+export const modelsCache = new NodeCache( { stdTTL: 100, checkperiod: 120 } );
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Helper to escape characters for regex.
+ * @param {string} str The string to escape.
+ * @returns {string} The escaped string.
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Generates a regular expression from a mask pattern and replacement rules.
+ * @param {string} mask - The mask pattern, e.g., '+0 (___) ___-__-__'.
+ * @param {object} replacement - An object mapping placeholder characters to regex patterns, e.g., { "_": "\\d" }.
+ * @returns {string|null} - A regular expression string or null if inputs are invalid.
+ */
+export function generateRegexFromMask(mask, replacement) {
+    if (!mask || !replacement || typeof replacement !== 'object') return null;
+
+    let regex = '^';
+    for (const char of mask) {
+        regex += replacement[char] ? `(${replacement[char]})` : escapeRegex(char);
+    }
+    regex += '$';
+    return regex;
+}
+
+export const mongoDBWhitelist = [
+    "$$NOW", "$in", "$eq", "$gt", "$gte", "$in", "$lt", "$lte", "$ne", "$nin", "$type", "$size",
+    "$and", "$not", "$nor", "$or", "$regexMatch", "$find", "$elemMatch", "$filter", "$toString", "$toObjectId",
+    "$concat",
+    '$add', '$subtract', '$multiply', '$divide', '$mod', '$pow', "$sqrt",
+    "$rand",
+    "$abs", '$sin', '$cos', '$tan', '$asin', '$acos', '$atan',
+    "$toDate", "$toBool", "$toString", "$toInt", "$toDouble",
+    "$dateDiff", "$dateSubtract", "$dateAdd", "$dateToString",
+    '$year', '$month', '$week', '$dayOfMonth', '$dayOfWeek', '$dayOfYear', '$hour', '$minute', '$second', '$millisecond',
+    '$geoNear', '$regex', '$text', '$nearSphere','$geoWithin','$geoIntersects'
+];
+export let importJobs = {};
+
+
+/**
+ * Exécute une tâche d'import/export (parsing, stringify) dans un worker thread.
+ * @param {('parse-json'|'parse-csv'|'stringify-json')} action - L'action à effectuer.
+ * @param {object} payload - Les données nécessaires pour l'action.
+ * @returns {Promise<any>} - Une promesse qui se résout avec les données traitées.
+ */
+export function runImportExportWorker(action, payload) {
+    return new Promise((resolve, reject) => {
+        const workerPath = path.resolve(process.cwd(), './src/workers/import-export-worker.js');
+        const worker = new Worker(workerPath);
+
+        worker.postMessage({ action, payload });
+
+        worker.on('message', (result) => {
+            if (result.success) {
+                resolve(result.data);
+            } else {
+                // Correction : On s'assure de toujours passer une chaîne de caractères à new Error()
+                const errorMessage = result.error || `Import/Export Worker failed with an unknown error. Action: ${action}.`;
+                reject(new Error(errorMessage));
+            }
+            worker.terminate();
+        });
+
+        worker.on('error', (err) => {
+            reject(err);
+            worker.terminate();
+        });
+
+        worker.on('exit', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Import/Export Worker stopped with exit code ${code}`));
+            }
+        });
+    });
+}
+/** Exécute une tâche de cryptographie dans un worker thread.
+ * @param {('encrypt'|'decrypt'|'hash')} action - L'action à effectuer.
+ * @param {object} payload - Les données nécessaires pour l'action.
+ * @returns {Promise<any>} - Une promesse qui se résout avec le résultat (si pertinent).
+ */
+export function runCryptoWorkerTask(action, payload) {
+    return new Promise((resolve, reject) => {
+        const workerPath = path.resolve(__dirname, '../../workers/crypto-worker.js');
+        const worker = new Worker(workerPath);
+
+        worker.postMessage({ action, payload });
+
+        worker.on('message', (result) => {
+            if (result.success) {
+                resolve(result.data); // Résout avec les données (ex: le hash) ou undefined si pas de retour
+            } else {
+                reject(new Error(result.error));
+            }
+            worker.terminate();
+        });
+
+        worker.on('error', (err) => {
+            reject(err);
+            worker.terminate();
+        });
+
+        worker.on('exit', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Crypto Worker stopped with exit code ${code}`));
+            }
+        });
+    });
 }