data-primals-engine 1.7.1 → 1.7.3

package/src/sso.js

@@ -5,6 +5,11 @@ import { cookiesSecret } from "./constants.js";
 import {UserProvider} from "./providers.js";
 import {getCollection} from "./modules/mongodb.js";
 import process from "process";
+import {Event} from "./events.js"
+import { randomBytes } from 'crypto';
+import bcrypt from 'bcrypt';
+import { sendEmail } from './email.js';
+import {getInternalSmtpConfig, getSmtpConfig} from "./modules/user.js";
 
 /**
  * @class SSOUserProvider
@@ -53,35 +58,70 @@ export class SSOUserProvider extends UserProvider {
 
         const email = profile.emails[0].value;
 
-        // 1. Chercher un utilisateur existant avec cet email.
-        const existingUser = await this.usersCollection.findOne({ email: email });
+        // 1. Chercher un contact existant avec cet email.
+        const contactCollection = getCollection("contact");
+        const existingContact = await contactCollection.findOne({ email: email });
 
-        if (existingUser) {
-            // TODO: Mettre à jour les informations de l'utilisateur si nécessaire (ex: nom, photo de profil)
-            // await this.usersCollection.updateOne({ _id: existingUser._id }, { $set: { lastLogin: new Date() } });
-            return existingUser;
+        if (existingContact) {
+            // 2. Si le contact existe, chercher l'utilisateur qui lui est lié.
+            const existingUser = await this.usersCollection.findOne({ contact: existingContact._id.toString() });
+            if (existingUser) {
+                // TODO: Mettre à jour les informations de l'utilisateur/contact si nécessaire (ex: nom, photo de profil)
+                return existingUser;
+            }
         }
 
-        // 2. Si aucun utilisateur n'est trouvé, en créer un nouveau.
+        // 3. Si aucun utilisateur n'est trouvé, en créer un nouveau avec son contact.
+        const [firstName, ...lastNameParts] = (profile.displayName || email).split(' ');
+        const lastName = lastNameParts.join(' ');
+
+        const newContact = {
+            _model: 'contact',
+            firstName: firstName,
+            lastName: lastName,
+            email: email,
+            // On pourrait ajouter le _user ici si on a un utilisateur "système" pour les créations SSO
+        };
+        const contactResult = await contactCollection.insertOne(newContact);
+
+        // Générer un mot de passe aléatoire et sécurisé que l'utilisateur ne connaîtra pas.
+        // Il pourra utiliser le flux "mot de passe oublié" s'il souhaite se connecter localement.
+        const randomPassword = randomBytes(32).toString('hex');
+        const saltRounds = 10;
+        const hashedPassword = await bcrypt.hash(randomPassword, saltRounds);
+
         const newUser = {
+            _model: 'user',
             username: email, // Utiliser l'email comme nom d'utilisateur par défaut
-            email: email,
-            name: profile.displayName || email,
+            contact: contactResult.insertedId.toString(),
             provider: profile.provider, // ex: 'google', 'saml'
             providerId: profile.id,
+            hash: hashedPassword, // Mot de passe haché pour une éventuelle connexion locale
             userPlan: 'free', // Assigner un plan par défaut
             createdAt: new Date()
         };
 
-        const result = await this.usersCollection.insertOne(newUser);
-        return await this.findUserById(result.insertedId);
+        const userResult = await this.usersCollection.insertOne(newUser);
+        const finalUser = await this.findUserById(userResult.insertedId);
+
+        // Envoyer un e-mail de bienvenue au nouvel utilisateur
+        const smtpConfig = getInternalSmtpConfig(finalUser);
+        sendEmail(email, { title: "Bienvenue !", content: "Votre compte a été créé avec succès." }, smtpConfig).catch(console.error);
+
+        return finalUser;
     }
 
     // Les autres méthodes comme validatePassword ne sont pas pertinentes pour le SSO.
     // On peut les laisser vides ou les faire lever une erreur.
     async validatePassword(user, password) { return false; }
     async findUserByUsername(username) { return await this.usersCollection.findOne({ username }); }
-    async initiateUser(req) { /* Géré par Passport */ }
+    async initiateUser(req) {
+        const username = req.query._user || req.headers._user || req.cookies.username;
+        const user = await this.findUserByUsername(username);
+        if (user) {
+            req.me = user; // Attache l'utilisateur à la requête
+        }
+    }
 }
 
 /**
@@ -162,19 +202,45 @@ export class Sso extends Behaviour {
 
         const app = this.gameObject;
 
-        // Créer la route d'initiation
-        app.get(routes.authPath, passport.authenticate(name, options));
-
-        // Créer la route de callback
-        app.get(
-            routes.callbackPath,
-            passport.authenticate(name, { failureRedirect: '/login', failureMessage: true }),
-            (req, res) => {
-                // Redirection après une authentification réussie
-                res.redirect(req.session.returnTo || '/dashboard');
-                delete req.session.returnTo;
-            }
-        );
+        // --- ROUTE D'INITIATION AMÉLIORÉE ---
+        // Nous utilisons un middleware personnalisé pour préserver l'état (query params).
+        app.get(routes.authPath, (req, res, next) => {
+            this.#logger.debug(`[SSO] Initiating '${name}' auth. Full returnTo URL stored: '${req.session.returnTo}'`);
+            
+            // On sauvegarde la session manuellement avant de rediriger vers le fournisseur SSO.
+            // Ceci garantit que `returnTo` est persisté.
+            req.session.save(() => {
+                passport.authenticate(name, options)(req, res, next);
+            });
+        });
+
+        // --- ROUTE DE CALLBACK AMÉLIORÉE ---
+        // Nous utilisons un callback personnalisé pour déclencher des événements.
+        app.get(routes.callbackPath, (req, res, next) => {
+            passport.authenticate(name, { failureRedirect: '/login', failureMessage: true }, async (err, user, info) => {
+                if (err) { return next(err); }
+                if (!user) { return res.redirect('/login'); }
+
+                // Sauvegarder l'URL de retour avant que req.logIn() ne régénère potentiellement la session.
+                const returnToUrl = req.session.returnTo;
+
+                req.logIn(user, async (loginErr) => {
+                    if (loginErr) { return next(loginErr); }
+
+                    // Restaurer l'URL de retour dans la nouvelle session.
+                    req.session.returnTo = returnToUrl;
+
+                    // *** DÉCLENCHEMENT DE L'ÉVÉNEMENT OnSSOLogin ***
+                    await Event.Trigger("OnSsoLogin", "event", "system", { req, res, user, ssoProfile: info?.profile });
+
+                    // Après que l'événement a mis à jour la session (par exemple, avec un nouveau token),
+                    // nous pouvons rediriger l'utilisateur.
+                    // On restaure une dernière fois au cas où la session aurait été régénérée.
+                    const finalReturnTo = req.session.returnTo || '/';
+                    res.redirect(finalReturnTo);
+                });
+            })(req, res, next);
+        });
 
         this.strategies.set(name, { strategy, routes, options });
         this.#logger.info(`Passport strategy '${name}' registered with routes: ${routes.authPath}, ${routes.callbackPath}`);

package/test/assistant.test.js

@@ -1,207 +1,208 @@
-// __tests__/assistant.test.js
-import { vi, expect, describe, it, beforeAll, afterAll, beforeEach } from 'vitest';
-import { Config } from '../src/config.js';
-import { getCollection, getCollectionForUser } from '../src/modules/mongodb.js';
-import { generateUniqueName, initEngine } from "../src/setenv.js";
-import { purgeData } from "../src/modules/data/data.history.js";
-import { handleChatRequest } from '../src/modules/assistant/assistant.js';
-import { insertData } from '../src/index.js';
-import * as dataOperations from '../src/modules/data/data.operations.js';
-
-// --- CORRECTION ---
-// On mock le nouveau module 'providers.js' qui contient la fonction que l'on veut surcharger.
-vi.mock('../src/modules/assistant/providers.js', () => ({
-    getAIProvider: vi.fn(),
-}));
-
-// On importe la version mockée de getAIProvider
-import { getAIProvider } from '../src/modules/assistant/providers.js';
-
-let testUser;
-let modelsCollection;
-let datasCollection;
-
-const modelName = generateUniqueName('productAssistant');
-
-describe('Assistant Module Unit Tests', () => {
-
-    beforeAll(async () => {
-        Config.Set("modules", ["mongodb", "data", "user", "assistant"]);
-        await initEngine(); // Cette ligne ne devrait plus planter.
-        testUser = {
-            username: generateUniqueName('testUserAssistant'),
-            email: generateUniqueName('test') + '@example.com',
-            lang: 'fr'
-        };
-
-        modelsCollection = getCollection('models');
-        datasCollection = await getCollectionForUser(testUser);
-
-        // Create a model for testing
-        const productModelDef = {
-            name: modelName,
-            description: 'A model for testing',
-            _user: testUser.username,
-            fields: [
-                { name: 'name', type: 'string', required: true },
-                { name: 'price', type: 'number' }
-            ]
-        };
-        await modelsCollection.insertOne(productModelDef);
-    });
-
-    beforeEach(async () => {
-        // Clear mocks before each test
-        vi.clearAllMocks();
-        // Clean data, but keep the model
-        await datasCollection.deleteMany({ _user: testUser.username });
-    });
-
-    // Helper to create a mock LLM stream
-    const createMockStream = (content) => {
-        return (async function* () {
-            yield { content };
-        })();
-    };
-
-    it('should return a simple text message from the AI', async () => {
-        const mockLLM = {
-            stream: vi.fn().mockReturnValue(createMockStream('Bonjour, ceci est un test.')),
-        };
-        getAIProvider.mockResolvedValue(mockLLM);
-
-        const params = { message: 'Dis bonjour', history: [] };
-        const result = await handleChatRequest(params, testUser);
-
-        expect(getAIProvider).toHaveBeenCalled();
-        expect(mockLLM.stream).toHaveBeenCalled();
-        expect(result).toEqual({
-            success: true,
-            displayMessage: 'Bonjour, ceci est un test.'
-        });
-    });
-
-    it('should handle a search action', async () => {
-
-        // Configure le retour du mock pour ce test spécifique
-        const searchDataSpy = vi.spyOn(dataOperations, 'searchData').mockResolvedValue({ data: [{ name: 'Test Widget', price: 100 }], count: 1 });
-
-        const aiResponse = JSON.stringify([
-            { action: 'search_models', params: { query: modelName } },
-            { action: 'search', params: { model: modelName, filter: {} } }
-        ]);
-        const mockLLM = {
-            stream: vi.fn().mockReturnValue(createMockStream(aiResponse))
-        };
-        getAIProvider.mockResolvedValue(mockLLM);
-
-        const params = { message: `cherche les produits`, history: [] };
-        const result = await handleChatRequest(params, testUser);
-
-        expect(searchDataSpy).toHaveBeenCalled();
-
-        expect(result.success).toBe(true);
-        expect(result.dataResult).toBeDefined();
-        expect(result.dataResult.model).toBe(modelName);
-        expect(result.dataResult.data).toHaveLength(1);
-        expect(result.dataResult.data[0].name).toBe('Test Widget');
-    });
-
-    it('should request confirmation for a "post" action', async () => {
-        const aiResponse = JSON.stringify({
-            action: 'post',
-            params: {
-                model: modelName,
-                data: { name: 'New Gadget', price: 19.99 }
-            }
-        });
-        const mockLLM = {
-            stream: vi.fn().mockReturnValue(createMockStream(aiResponse)),
-        };
-        getAIProvider.mockResolvedValue(mockLLM);
-
-        const params = { message: 'Crée un produit', history: [] };
-        const result = await handleChatRequest(params, testUser);
-
-        expect(result.success).toBe(true);
-        expect(result.confirmationRequest).toBeDefined();
-        expect(result.confirmationRequest.action).toBe('post');
-        expect(result.confirmationRequest.params.model).toBe(modelName);
-        expect(result.confirmationRequest.params.data.name).toBe('New Gadget');
-    });
-
-    it('should execute a confirmed "post" action', async () => {
-        const confirmedAction = {
-            action: 'post',
-            params: {
-                model: modelName,
-                data: { name: 'Confirmed Gadget', price: 50 }
-            }
-        };
-
-        const params = { message: '', confirmedAction };
-        const result = await handleChatRequest(params, testUser);
-
-        expect(result.success).toBe(true);
-        // --- CORRECTION ---
-        // On vérifie le message de succès spécifique à la création, qui est plus informatif.
-        expect(result.displayMessage).toContain("Élément créé avec l'ID:");
-
-        // Verify the data was actually inserted
-        const dataInDb = await datasCollection.findOne({ name: 'Confirmed Gadget' });
-        expect(dataInDb).not.toBeNull();
-        expect(dataInDb.price).toBe(50);
-    });
-
-    it('should handle malformed JSON from AI by returning it as a text message', async () => {
-        const aiResponse = `{ "action": "search", "params": { "model": "${modelName}" }`; // Missing closing brace
-        const mockLLM = {
-            stream: vi.fn().mockReturnValue(createMockStream(aiResponse)),
-        };
-        getAIProvider.mockResolvedValue(mockLLM);
-
-        const params = { message: 'test', history: [] };
-        const result = await handleChatRequest(params, testUser);
-
-        expect(result.success).toBe(true);
-        expect(result.displayMessage).toBe(aiResponse);
-    });
-
-    it('should correct a malformed filter from the AI', async () => {
-        const aiResponse = JSON.stringify([{
-            action: 'search',
-            params: {
-                model: modelName,
-                // This filter is malformed: multiple operators at the root level
-                filter: {
-                    "$gt": ["$price", 50],
-                    "$lt": ["$price", 200]
-                }
-            }
-        }]);
-        const mockLLM = {
-            stream: vi.fn().mockReturnValue(createMockStream(aiResponse)),
-        };
-        getAIProvider.mockResolvedValue(mockLLM);
-
-        // Configure le retour du mock pour ce test spécifique
-        const searchDataSpy = vi.spyOn(dataOperations, 'searchData').mockResolvedValue({ data: [], count: 0 });
-
-        const params = { message: 'cherche produits entre 50 et 200', history: [] };
-        // On peut maintenant utiliser la fonction handleChatRequest importée normalement
-        await handleChatRequest(params, testUser);
-
-        // On s'attend à ce que le filtre ait été encapsulé dans un $and
-        const expectedFilter = {
-            "$and": [
-                { "$gt": ["$price", 50] },
-                { "$lt": ["$price", 200] }
-            ]
-        };
-
-        expect(searchDataSpy).toHaveBeenCalledWith(expect.objectContaining({ filter: expectedFilter }), expect.anything());
-
-        // On nettoie l'espion après le test
-        searchDataSpy.mockRestore();
-    });
+// __tests__/assistant.test.js
+import { vi, expect, describe, it, beforeAll, afterAll, beforeEach } from 'vitest';
+import { Config } from '../src/config.js';
+import { getCollection, getCollectionForUser } from '../src/modules/mongodb.js';
+import { generateUniqueName, initEngine } from "../src/setenv.js";
+import { purgeData } from "../src/modules/data/data.history.js";
+import { handleChatRequest } from '../src/modules/assistant/assistant.js';
+import { insertData } from '../src/index.js';
+import * as dataOperations from '../src/modules/data/data.operations.js';
+
+// --- CORRECTION ---
+// On mock le nouveau module 'providers.js' qui contient la fonction que l'on veut surcharger.
+vi.mock('../src/modules/assistant/providers.js', () => ({
+    getAIProvider: vi.fn(),
+    findFirstAvailableProvider: vi.fn().mockResolvedValue({ provider: 'OpenAI', apiKey: 'mock-api-key' }),
+}));
+
+// On importe la version mockée de getAIProvider
+import { getAIProvider, findFirstAvailableProvider } from '../src/modules/assistant/providers.js';
+
+let testUser;
+let modelsCollection;
+let datasCollection;
+
+const modelName = generateUniqueName('productAssistant');
+
+describe('Assistant Module Unit Tests', () => {
+
+    beforeAll(async () => {
+        Config.Set("modules", ["mongodb", "data", "user", "assistant"]);
+        await initEngine(); // Cette ligne ne devrait plus planter.
+        testUser = {
+            username: generateUniqueName('testUserAssistant'),
+            email: generateUniqueName('test') + '@example.com',
+            lang: 'fr'
+        };
+
+        modelsCollection = getCollection('models');
+        datasCollection = await getCollectionForUser(testUser);
+
+        // Create a model for testing
+        const productModelDef = {
+            name: modelName,
+            description: 'A model for testing',
+            _user: testUser.username,
+            fields: [
+                { name: 'name', type: 'string', required: true },
+                { name: 'price', type: 'number' }
+            ]
+        };
+        await modelsCollection.insertOne(productModelDef);
+    });
+
+    beforeEach(async () => {
+        // Clear mocks before each test
+        vi.clearAllMocks();
+        // Clean data, but keep the model
+        await datasCollection.deleteMany({ _user: testUser.username });
+    });
+
+    // Helper to create a mock LLM stream
+    const createMockStream = (content) => {
+        return (async function* () {
+            yield { content };
+        })();
+    };
+
+    it('should return a simple text message from the AI', async () => {
+        const mockLLM = {
+            stream: vi.fn().mockReturnValue(createMockStream('Bonjour, ceci est un test.')),
+        };
+        getAIProvider.mockResolvedValue(mockLLM);
+
+        const params = { message: 'Dis bonjour', history: [] };
+        const result = await handleChatRequest(params, testUser);
+
+        expect(getAIProvider).toHaveBeenCalled();
+        expect(mockLLM.stream).toHaveBeenCalled();
+        expect(result).toEqual({
+            success: true,
+            displayMessage: 'Bonjour, ceci est un test.'
+        });
+    });
+
+    it('should handle a search action', async () => {
+
+        // Configure le retour du mock pour ce test spécifique
+        const searchDataSpy = vi.spyOn(dataOperations, 'searchData').mockResolvedValue({ data: [{ name: 'Test Widget', price: 100 }], count: 1 });
+
+        const aiResponse = JSON.stringify([
+            { action: 'search_models', params: { query: modelName } },
+            { action: 'search', params: { model: modelName, filter: {} } }
+        ]);
+        const mockLLM = {
+            stream: vi.fn().mockReturnValue(createMockStream(aiResponse))
+        };
+        getAIProvider.mockResolvedValue(mockLLM);
+
+        const params = { message: `cherche les produits`, history: [] };
+        const result = await handleChatRequest(params, testUser);
+
+        expect(searchDataSpy).toHaveBeenCalled();
+
+        expect(result.success).toBe(true);
+        expect(result.dataResult).toBeDefined();
+        expect(result.dataResult.model).toBe(modelName);
+        expect(result.dataResult.data).toHaveLength(1);
+        expect(result.dataResult.data[0].name).toBe('Test Widget');
+    });
+
+    it('should request confirmation for a "post" action', async () => {
+        const aiResponse = JSON.stringify({
+            action: 'post',
+            params: {
+                model: modelName,
+                data: { name: 'New Gadget', price: 19.99 }
+            }
+        });
+        const mockLLM = {
+            stream: vi.fn().mockReturnValue(createMockStream(aiResponse)),
+        };
+        getAIProvider.mockResolvedValue(mockLLM);
+
+        const params = { message: 'Crée un produit', history: [] };
+        const result = await handleChatRequest(params, testUser);
+
+        expect(result.success).toBe(true);
+        expect(result.confirmationRequest).toBeDefined();
+        expect(result.confirmationRequest.action).toBe('post');
+        expect(result.confirmationRequest.params.model).toBe(modelName);
+        expect(result.confirmationRequest.params.data.name).toBe('New Gadget');
+    });
+
+    it('should execute a confirmed "post" action', async () => {
+        const confirmedAction = {
+            action: 'post',
+            params: {
+                model: modelName,
+                data: { name: 'Confirmed Gadget', price: 50 }
+            }
+        };
+
+        const params = { message: '', confirmedAction };
+        const result = await handleChatRequest(params, testUser);
+
+        expect(result.success).toBe(true);
+        // --- CORRECTION ---
+        // On vérifie le message de succès spécifique à la création, qui est plus informatif.
+        expect(result.displayMessage).toContain("Élément créé avec l'ID:");
+
+        // Verify the data was actually inserted
+        const dataInDb = await datasCollection.findOne({ name: 'Confirmed Gadget' });
+        expect(dataInDb).not.toBeNull();
+        expect(dataInDb.price).toBe(50);
+    });
+
+    it('should handle malformed JSON from AI by returning it as a text message', async () => {
+        const aiResponse = `{ "action": "search", "params": { "model": "${modelName}" }`; // Missing closing brace
+        const mockLLM = {
+            stream: vi.fn().mockReturnValue(createMockStream(aiResponse)),
+        };
+        getAIProvider.mockResolvedValue(mockLLM);
+
+        const params = { message: 'test', history: [] };
+        const result = await handleChatRequest(params, testUser);
+
+        expect(result.success).toBe(true);
+        expect(result.displayMessage).toBe(aiResponse);
+    });
+
+    it('should correct a malformed filter from the AI', async () => {
+        const aiResponse = JSON.stringify([{
+            action: 'search',
+            params: {
+                model: modelName,
+                // This filter is malformed: multiple operators at the root level
+                filter: {
+                    "$gt": ["$price", 50],
+                    "$lt": ["$price", 200]
+                }
+            }
+        }]);
+        const mockLLM = {
+            stream: vi.fn().mockReturnValue(createMockStream(aiResponse)),
+        };
+        getAIProvider.mockResolvedValue(mockLLM);
+
+        // Configure le retour du mock pour ce test spécifique
+        const searchDataSpy = vi.spyOn(dataOperations, 'searchData').mockResolvedValue({ data: [], count: 0 });
+
+        const params = { message: 'cherche produits entre 50 et 200', history: [] };
+        // On peut maintenant utiliser la fonction handleChatRequest importée normalement
+        await handleChatRequest(params, testUser);
+
+        // On s'attend à ce que le filtre ait été encapsulé dans un $and
+        const expectedFilter = {
+            "$and": [
+                { "$gt": ["$price", 50] },
+                { "$lt": ["$price", 200] }
+            ]
+        };
+
+        expect(searchDataSpy).toHaveBeenCalledWith(expect.objectContaining({ filter: expectedFilter }), expect.anything());
+
+        // On nettoie l'espion après le test
+        searchDataSpy.mockRestore();
+    });
 });