data-primals-engine 1.4.0 → 1.4.2

package/src/modules/assistant/assistant.js

@@ -58,7 +58,7 @@ async function searchModels(query, user) {
         $or: [{ _user: user.username }, { _user: { $exists: false } }],
         $and: [{ $or: [{ name: { $regex: searchRegex } }, { description: { $regex: searchRegex } }] }]
     }, {
-        projection: { name: 1, description: 1, _id: 0 }
+        projection: { name: 1, description: 1, fields: 1, _id: 0 }
     }).limit(10).toArray();
 }
 
@@ -74,39 +74,49 @@ const createSystemPrompt = (modelDefs, lang) => {
 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.
 
+REGLE FONDATRICE : suis les règles et ne dévie pas du chemin.
+STYLE UTILISE : apporte l'information au plus rapide, sans détours, ni sollicitation à l'utilisateur, ou à des tiers.
 
 FORMAT DE RÉPONSE OBLIGATOIRE :
 Un SEUL objet JSON valide contenant exactement 2 champs :
 1. "action" (string) 
 2. "params" (object)
-    2.1 : query (string) : Les mots clés de la recherche
-    2.2 : filter (object) : Les filtres de la recherche
-    2.3 : limit (number) : Le nombre de résultats à afficher
-    2.4 : sort (string) : La clé de tri de la recherche
-    2.6 : model (string) : Le nom du modèle à utiliser
-    2.7 : data (object) : Les données à ajouter à la base de données
-
-Tu as accès aux outils suivants. 
-
-NOUVEL OUTIL PRIORITAIRE:
-1.  **search_models**: À utiliser EN PREMIER SI TU NE SAIS PAS QUEL MODÈLE UTILISER pour répondre à la question de l'utilisateur. Si tu l'as déjà recherché, garde la définition initiale et n'effectue pas de recherche.
-    - Utilisation: { "action": "search_models", "params": { "query": "mots-clés de la recherche" } }
-    
-1.  **search**: Pour chercher des informations dans les données de l'utilisateur.
+
+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$" } }
+====
+
+ACTIONS FINALES: (Actions qui terminent ta réflexion et renvoient un résultat à l'utilisateur)
+1.  **search**: Pour chercher des informations et les AFFICHER à l'utilisateur sous forme de tableau.
     - Utilisation: { "action": "search", "params": { "model": "nomDuModele", "filter": {}, "limit": 10 } }
 
-2.  **post**: Pour créer une nouvelle donnée.
+2.  **post**: Pour créer une nouvelle donnée (nécessite confirmation).
     - Utilisation: { "action": "post", "params": { "model": "nomDuModele", "data": {} } }
 
-3.  **update**: Pour mettre à jour des données existantes.
+3.  **update**: Pour mettre à jour des données existantes (nécessite confirmation).
     - Utilisation: { "action": "update", "params": { "model": "nomDuModele", "filter": {}, "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.
+4.  **delete**: Pour supprimer des données (nécessite confirmation).
     - Utilisation: { "action": "delete", "params": { "model": "nomDuModele", "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.
+5.  **displayMessage**: Pour répondre avec un simple message texte. 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." } }
+    
+6.  **generateChart**: Pour créer et afficher un graphique. 
+    - Utilisation: { "action": "generateChart", "params": { ...config } }
+    - Le paramètre \`config\` doit contenir :
+        - \`title\` (string): Un titre clair pour le graphique.
+        - \`model\` (string): Le nom du modèle de données à utiliser.
+        - \`type\` (string): Le type de graphique. Peut être 'bar', 'line', 'pie', 'doughnut'.
+        - \`aggregationType\` (string): Comment agréger les données. 'count' (par défaut), 'sum', 'avg', 'min', 'max'.
+        - \`xAxis\` (string): (Pour bar/line) Le champ pour l'axe des X. Un champ de type date, enum ou string du modèle.
+        - \`groupBy\` (string): (Pour pie/doughnut) Le champ sur lequel grouper les données (un champ enum ou relation du modèle).
+        - \`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) 
 
 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 
@@ -125,15 +135,14 @@ 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. Si le nom du modèle n'est pas évident, utilise d'abord l'outil "search_models" pour trouver le bon modèle.
-3. Une fois le modèle identifié, utilise les autres outils (search, post, etc.) pour effectuer l'action.
-4. Si tu as assez d'informations, réponds à l'utilisateur avec "displayMessage".
-
-Chacune de tes réponses doit être une étape en soi, ou au plus près d'une étape.
+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".
 
 CONTEXTE ACTUEL:
-- Date du jour de ton conversateur : ${dt}
+- Date du jour de la conversation : ${dt}
 - La langue ISO à utiliser dans la conversation : ${lang}
 - L'utilisateur a accès aux modèles de données suivants et ne peut utiliser les filtres que sur les champs associés:
 Si tu as besoin de savoir lesquels, utilise l'outil "search_models".
@@ -143,38 +152,91 @@ Si tu as besoin de savoir lesquels, utilise l'outil "search_models".
 
 Par exemple :  
 Question : Je voudrais les événements non terminés, qui ne sont pas des festivals ou des salons :
-Réponse : { "action" : "search", "params" : ${cond1} }
+Ta réponse: { "action" : "search_models", "params": { "query": "event|événement" } }
+COMMANDE FINALE : { "action" : "search", "params" : ${cond1} }
 
 Question : Donne moi les 5 nouvelles entreprises
-Réponse : { "action" : "search", "params" : ${cond2} }
+Ta réponse: { "action" : "search_models", "params": { "query": "company|entreprise" } }
+COMMANDE FINALE : { "action" : "search", "params" : ${cond2} }
 
 Question : Je veux les 10 dernières traductions ajoutées dans la langue française.
-Réponse : { "action" : "search", "params" : ${cond3} }
+Ta réponse: { "action" : "search_models", "params": { "query": "translation|traduction" } }
+COMMANDE FINALE : { "action" : "search", "params" : ${cond3} }
 
 Question : Je veux les commandes qui ont été faites par un admin ou un modérateur
-Réponse : { "action" : "search", "params" : ${cond4} }
-====
+Ta réponse: { "action" : "search_models", "params": { "query": "order|commande" } }
+COMMANDE FINALE : { "action" : "search", "params" : ${cond4} }
+
+Question : Fais-moi un camembert des produits par catégorie.
+Ta réponse: { "action" : "search_models", "params": { "query": "product|produit" } }
+COMMANDE FINALE :
+{
+  "action": "generateChart",
+  "params": {
+    "title": "Répartition des produits par catégorie",
+    "model": "product",
+    "type": "pie",
+    "groupBy": "category",
+    "aggregationType": "count",
+    "filter": { "$and": [{"$gt": ["$publishedAt", "2023-10-05T20:12:00Z"]}, {"$lte": ["$publishedAt", "2024-10-05T20:12:00Z"]} ]}
+  }
+}
 
+Absolute rules:
+====
 NEVER use the non-aggregated syntax of the MongoDB operators :
-Use { '$gt': ["$publishedAt", "2023-10-05T20:12:00Z" } } } and NOT { publishedAt: { '$gt': '2023-10-05T20:12:00Z' } } }
+Use { "$gt": ["$publishedAt", "2023-10-05T20:12:00Z" ] } and NOT { "publishedAt": { "$gt": "2023-10-05T20:12:00Z" } }
+=====
+If several filters must be combined or juxtaposed, the operators $and, $or, $nor, $not MUST be used to make the logic.
+You need at least one of these operators.
+Example : 
+Use filters like this: { "$and": [{"$gt": ["$publishedAt", "2023-10-05T20:12:00Z"]}, {"$lte": ["$publishedAt", "2024-10-05T20:12:00Z"]} ]}
+You MUST NOT write filters like this : {"$gt": ["$publishedAt", "2023-10-05T20:12:00Z"], "$lte": ["$publishedAt", "2024-10-05T20:12:00Z"]}  without the $and operator
 =====
 Et si tu dois utiliser une date :
 "2025-08-05T20:12:00Z" au lieu de { "$date": "2025-08-05T20:12:00Z" }
 =====
-Si plusieurs filtres doivent être combinés, utilise OBLIGATOIREMENT les opérateurs $and, $or, $nor, $not
-=====
-
-Règles ABSOLUES:
 - UNE SEULE COMMANDE JSON PAR RÉPONSE
 - AUCUN TEXTE HORS DU JSON
+- PAS de MARKDOWN pour formatter le JSON, juste le JSON {...} brut.
+=====
 
 Exemple d'échange correct :
 
 Ma question: Bonjour, je voudrais les requêtes effectuées aujourd'hui sur le modèle "content".
-Ta réponse:
+Ta réponse: { "action" : "search_models", "params": { "query": "request" } }
+COMMANDE FINALE : 
 { "action" : "search", "params" : { "model": "request", "filter": { "$and": [{"$gte": "${dt}"}, {"$regexMatch": { "input": "$url", "regex": "content"}}] }, "limit" : 10, "sort" : "_id:DESC" }}`;
 }
 
+/**
+ * Corrige un filtre généré par l'IA qui pourrait avoir plusieurs opérateurs
+ * au premier niveau sans les encapsuler dans un "$and".
+ * @param {object} filter - Le filtre potentiellement incorrect.
+ * @returns {object} Le filtre corrigé.
+ */
+function correctAIFilter(filter) {
+    if (!filter || typeof filter !== 'object' || Array.isArray(filter)) {
+        return filter; // Pas un objet à corriger
+    }
+
+    const keys = Object.keys(filter);
+    if (keys.length <= 1) {
+        return filter; // Rien à corriger
+    }
+
+    // Vérifie si toutes les clés sont des opérateurs (commencent par '$')
+    const allKeysAreOperators = keys.every(key => key.startsWith('$'));
+
+    if (allKeysAreOperators) {
+        logger.warn(`[Assistant] Correction d'un filtre malformé généré par l'IA. Original: ${JSON.stringify(filter)}`);
+        const andConditions = keys.map(key => ({ [key]: filter[key] }));
+        return { '$and': andConditions };
+    }
+
+    return filter; // Aucune correction nécessaire
+}
+
 /**
  * Exécute un outil (tool) non-modifiant et retourne le résultat sous forme de chaîne.
  * @param {string} action - L'action à exécuter ('search', 'search_models').
@@ -216,7 +278,7 @@ async function executeTool(action, params, user, allModels) {
 
             if (foundModels.length > 0) {
                 return "J'ai trouvé les modèles suivants qui pourraient correspondre : " +
-                        foundModels.map(m => `\n- Modèle "${m.name}": ${m.description || 'Pas de description.'}`).join('');
+                        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('');
             } else {
                 return "Je n'ai trouvé aucun modèle correspondant à votre recherche.";
             }
@@ -286,7 +348,7 @@ async function handleChatRequest(message, history, provider, context, user, conf
     // --- PRÉPARATION DE L'HISTORIQUE DE CONVERSATION ---
     const systemPrompt = createSystemPrompt([], user.lang || 'en');
     const conversationHistory = history
-        .filter(msg => !(msg.from === 'bot' && msg.text.startsWith(i18n.t('assistant.welcome'))))
+        .filter(msg => msg.text && !(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));
@@ -317,11 +379,38 @@ async function handleChatRequest(message, history, provider, context, user, conf
             };
         }
 
-        logger.debug(`[Assistant] Action décidée par l'IA: ${parsedResponse.action}`);
+        logger.debug(`[Assistant] Action décidée par l'IA: ${parsedResponse.action}`, parsedResponse);
         conversationHistory.push(new SystemMessage(JSON.stringify(parsedResponse)));
 
         const { action, params } = parsedResponse;
 
+        // Correction automatique du filtre généré par l'IA, qui hallucine parfois
+        if (params && params.filter) {
+            logger.debug(`[Assistant] Filtre original de l'IA: ${JSON.stringify(params.filter)}`);
+            params.filter = correctAIFilter(params.filter);
+        }
+
+        // Action de génération de graphique, gérée par le front-end
+        if (action === 'generateChart') {
+            // On retourne directement la configuration du graphique au client.
+            return { success: true, chartConfig: params };
+        }
+
+        // NOUVEAU: Action de recherche à afficher, gérée par le front-end
+        if (action === 'search') {
+            const searchResult = await searchData({
+                model: params.model,
+                filter: params.filter,
+                limit: params.limit || 10,
+                sort: params.sort
+            }, user);
+            if (searchResult.data?.length > 0) {
+                return { success: true, dataResult: { model: params.model, data: searchResult.data } };
+            } else {
+                return { success: true, displayMessage: i18n.t('assistant.search.noResults', "Je n'ai trouvé aucun résultat.") };
+            }
+        }
+
         // Actions nécessitant une confirmation de l'utilisateur
         if (['post', 'update', 'delete'].includes(action)) {
             const confirmationMessage = i18n.t('assistant.confirmActionPrompt', "Veuillez confirmer l'action suivante :");
@@ -337,8 +426,8 @@ async function handleChatRequest(message, history, provider, context, user, conf
             return { success: true, displayMessage: params.message };
         }
 
-        // Actions à exécuter immédiatement (outils)
-        if (['search', 'search_models'].includes(action)) {
+        // Outils pour le raisonnement interne de l'IA
+        if (['search_models'].includes(action)) { // On a enlevé 'search' d'ici
             const toolResult = await executeTool(action, params, user, allModels);
             conversationHistory.push(new SystemMessage(`Résultat de l'outil '${action}':\n${toolResult}`));
             continue; // On continue la boucle pour que l'IA puisse raisonner avec ce nouveau résultat

package/src/modules/auth-google/index.js

@@ -0,0 +1,51 @@
+import { Strategy as GoogleStrategy } from 'passport-google-oauth20';
+import { Sso, SSOUserProvider } from '../../sso.js';
+import {Logger} from "../../gameObject.js";
+
+let logger;
+
+export async function onInit(engine) {
+    logger = engine.getComponent(Logger);
+
+    // Le SSOUserProvider est nécessaire pour l'initialisation et pour la stratégie.
+    // On le crée donc en premier.
+    const ssoUserProvider = new SSOUserProvider(engine);
+
+    // 1. Récupérer le composant PassportAuth central.
+    let passportAuth = engine.getComponent(Sso);
+    if (!passportAuth) {
+        passportAuth = engine.addComponent(Sso);
+        // C'EST ICI QUE L'INITIALISATION DOIT AVOIR LIEU, UNE SEULE FOIS.
+        passportAuth.initialize({ ssoUserProvider });
+        passportAuth.addLogoutRoute();
+        logger.info("[auth-google] Sso component was not found, created and initialized a new one.");
+    }
+
+    // 2. Vérifier que les variables d'environnement nécessaires sont présentes.
+    if (!process.env.GOOGLE_CLIENT_ID || !process.env.GOOGLE_CLIENT_SECRET) {
+        logger.warn("[auth-google] GOOGLE_CLIENT_ID or GOOGLE_CLIENT_SECRET are not set. Google SSO will be disabled.");
+        return;
+    }
+
+    // 3. Créer l'instance de la stratégie Google.
+    const googleStrategy = new GoogleStrategy({
+        clientID: process.env.GOOGLE_CLIENT_ID,
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+        callbackURL: "/api/auth/google/callback"
+    },
+    async (accessToken, refreshToken, profile, done) => {
+        try {
+            // On utilise le SSOUserProvider pour trouver ou créer l'utilisateur.
+            const user = await ssoUserProvider.findOrCreate(profile);
+            return done(null, user);
+        } catch (err) {
+            return done(err);
+        }
+    });
+
+    // 4. Enregistrer la stratégie auprès du composant PassportAuth.
+    passportAuth.addStrategy('google', googleStrategy,
+        { authPath: '/api/auth/google', callbackPath: '/api/auth/google/callback' },
+        { scope: ['profile', 'email'] }
+    );
+}

package/src/modules/auth-microsoft/index.js

@@ -0,0 +1,82 @@
+import { Sso, SSOUserProvider } from '../../sso.js';
+import { Logger } from "../../gameObject.js";
+
+let logger;
+
+export async function onInit(engine) {
+    logger = engine.getComponent(Logger);
+
+    try {
+        // 1. Tenter d'importer dynamiquement la stratégie Azure AD.
+        // L'utilisateur devra exécuter `npm install passport-azure-ad`.
+        const { OIDCStrategy } = await import('passport-azure-ad');
+
+        const ssoUserProvider = new SSOUserProvider(engine);
+
+        // 2. Récupérer ou créer le composant SSO central.
+        let ssoComponent = engine.getComponent(Sso);
+        if (!ssoComponent) {
+            ssoComponent = engine.addComponent(Sso);
+            ssoComponent.initialize({ ssoUserProvider });
+            ssoComponent.addLogoutRoute();
+            logger.info("[auth-microsoft] Sso component was not found, created and initialized a new one.");
+        }
+
+        // 3. Vérifier les variables d'environnement critiques pour Azure AD.
+        const { MICROSOFT_CLIENT_ID, MICROSOFT_CLIENT_SECRET, MICROSOFT_TENANT_ID } = process.env;
+        if (!MICROSOFT_CLIENT_ID || !MICROSOFT_CLIENT_SECRET || !MICROSOFT_TENANT_ID) {
+            logger.warn("[auth-microsoft] Microsoft environment variables are not fully set. Microsoft SSO will be disabled.");
+            return;
+        }
+
+        const callbackUrl = process.env.MICROSOFT_CALLBACK_URL || '/api/auth/microsoft/callback';
+
+        // 4. Créer l'instance de la stratégie OIDC pour Microsoft.
+        const microsoftStrategy = new OIDCStrategy({
+            identityMetadata: `https://login.microsoftonline.com/${MICROSOFT_TENANT_ID}/v2.0/.well-known/openid-configuration`,
+            clientID: MICROSOFT_CLIENT_ID,
+            responseType: 'code id_token',
+            responseMode: 'form_post',
+            redirectUrl: callbackUrl,
+            allowHttpForRedirectUrl: process.env.NODE_ENV !== 'production',
+            clientSecret: MICROSOFT_CLIENT_SECRET,
+            validateIssuer: false, // Important pour les tenants multiples
+            passReqToCallback: false,
+            scope: ['profile', 'email', 'openid']
+        },
+        async (iss, sub, profile, accessToken, refreshToken, done) => {
+            try {
+                // Le profil Azure AD est différent. On l'adapte à notre format standard.
+                const email = profile.upn || profile._json.email;
+                if (!email) {
+                    return done(new Error("Microsoft profile is missing an email (upn)."));
+                }
+
+                const adaptedProfile = {
+                    provider: 'azuread',
+                    id: profile.oid, // Object ID de l'utilisateur dans Azure
+                    displayName: profile.displayName,
+                    emails: [{ value: email }]
+                };
+
+                const user = await ssoUserProvider.findOrCreate(adaptedProfile);
+                return done(null, user);
+            } catch (err) {
+                return done(err);
+            }
+        });
+
+        // 5. Enregistrer la stratégie auprès du composant SSO.
+        ssoComponent.addStrategy('azuread-openidconnect', microsoftStrategy, {
+            authPath: '/api/auth/microsoft',
+            callbackPath: callbackUrl
+        });
+
+    } catch (e) {
+        if (e.code === 'ERR_MODULE_NOT_FOUND') {
+            logger.info("[auth-microsoft] Module désactivé. Pour l'activer, exécutez 'npm install passport-azure-ad'");
+        } else {
+            logger.error("[auth-microsoft] Une erreur inattendue a empêché le chargement du module :", e);
+        }
+    }
+}

package/src/modules/auth-saml/index.js

@@ -0,0 +1,90 @@
+import { Sso, SSOUserProvider } from '../../sso.js';
+import { Logger } from "../../gameObject.js";
+
+let logger;
+
+export async function onInit(engine) {
+    logger = engine.getComponent(Logger);
+
+    try {
+        // 1. Tenter d'importer dynamiquement la stratégie SAML.
+        // Cela ne fonctionnera que si l'utilisateur a exécuté `npm install passport-saml-encrypted`.
+        const { Strategy: SamlStrategy } = await import('passport-saml-encrypted');
+
+        const ssoUserProvider = new SSOUserProvider(engine);
+
+        // 2. Récupérer le composant SSO central.
+        let ssoComponent = engine.getComponent(Sso);
+        if (!ssoComponent) {
+            // S'il n'existe pas, on l'ajoute. C'est le premier module SSO à se charger.
+            ssoComponent = engine.addComponent(Sso);
+            ssoComponent.initialize({ ssoUserProvider });
+            ssoComponent.addLogoutRoute();
+            logger.info("[auth-saml] Sso component was not found, created and initialized a new one.");
+        }
+
+        // 3. Vérifier les variables d'environnement critiques pour SAML.
+        const { SAML_ENTRY_POINT, SAML_ISSUER, SAML_CERT, SAML_CALLBACK_URL, SAML_DECRYPTION_KEY } = process.env;
+        if (!SAML_ENTRY_POINT || !SAML_ISSUER || !SAML_CERT || !SAML_DECRYPTION_KEY) {
+            logger.warn("[auth-saml] SAML environment variables (SAML_ENTRY_POINT, SAML_ISSUER, SAML_CERT, SAML_DECRYPTION_KEY) are not fully set. SAML SSO will be disabled.");
+            return;
+        }
+
+        const callbackUrl = SAML_CALLBACK_URL || '/api/auth/saml/callback';
+
+        // 4. Créer l'instance de la stratégie SAML.
+        // La configuration SAML est plus complexe que OAuth2.
+        const samlStrategy = new SamlStrategy(
+            {
+                path: callbackUrl, // Le chemin où l'IdP (Identity Provider) enverra la réponse POST.
+                entryPoint: SAML_ENTRY_POINT, // L'URL de connexion de l'IdP.
+                issuer: SAML_ISSUER, // L'identifiant de votre application (Service Provider).
+                cert: SAML_CERT, // Le certificat public de l'IdP pour vérifier la signature.
+                decryptionPvk: SAML_DECRYPTION_KEY, // Clé privée pour déchiffrer les assertions.
+                encryptedSAML: true, // Indique que nous attendons des assertions chiffrées.
+                acceptedClockSkewMs: -1 // Optionnel mais recommandé: pour les problèmes de synchronisation d'horloge.
+            },
+            async (profile, done) => {
+                try {
+                    // Normaliser les clés du profil en minuscules pour une correspondance insensible à la casse.
+                    const normalizedProfile = Object.keys(profile).reduce((acc, key) => {
+                        acc[key.toLowerCase()] = profile[key];
+                        return acc;
+                    }, {});
+
+                    // Le profil SAML est différent du profil Google. Nous devons l'adapter.
+                    // `nameID` est souvent l'email. Les autres attributs dépendent de la configuration de l'IdP.
+                    const email = normalizedProfile.email || normalizedProfile.nameid;
+                    if (!email) {
+                        return done(new Error("SAML profile is missing an email or nameID."));
+                    }
+
+                    const adaptedProfile = {
+                        provider: 'saml',
+                        id: normalizedProfile.nameid,
+                        displayName: normalizedProfile.displayname || normalizedProfile.cn || `${normalizedProfile.firstname || ''} ${normalizedProfile.lastname || ''}`.trim() || email,
+                        emails: [{ value: email }]
+                    };
+
+                    const user = await ssoUserProvider.findOrCreate(adaptedProfile);
+                    return done(null, user);
+                } catch (err) {
+                    return done(err);
+                }
+            }
+        );
+
+        // 5. Enregistrer la stratégie auprès du composant SSO.
+        ssoComponent.addStrategy('saml', samlStrategy, {
+            authPath: '/api/auth/saml',
+            callbackPath: callbackUrl
+        });
+
+    } catch (e) {
+        if (e.code === 'ERR_MODULE_NOT_FOUND') {
+            logger.info("[auth-saml] Module désactivé. Pour l'activer, exécutez 'npm install passport-saml-encrypted'");
+        } else {
+            logger.error("[auth-saml] Une erreur inattendue a empêché le chargement du module :", e);
+        }
+    }
+}

package/src/modules/bucket.js

@@ -12,6 +12,7 @@ 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";
 
 const restoreRequests = {};
 
@@ -21,11 +22,11 @@ export const requestRestore = async (user, lang) => {
     const modelsRestoreToken = crypto.randomBytes(32).toString('hex');
     const expiration = new Date(Date.now() + 30 * 60 * 1000); // 30 minutes
 
-    restoreRequests[user?.username] = {
+    safeAssignObject(restoreRequests, user?.username, {
         fullToken: fullRestoreToken,
         modelsToken: modelsRestoreToken,
         expiresAt: expiration
-    };
+    });
 
     i18n.changeLanguage(lang);