data-primals-engine 1.7.2 → 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/cluster.test.js

@@ -0,0 +1,221 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { initializeCluster, getMemberList, stopClusterServices } from '../src/modules/data/data.cluster.js';
+import * as fs from 'node:fs/promises';
+import { Logger } from "../src/index.js";
+import { Config } from '../src/config.js';
+
+// Mock Logger to prevent console output
+vi.mock('../src/gameObject.js', async (importOriginal) => {
+    const original = await importOriginal();
+    return {
+        ...original, // Keep original exports like 'Behaviour'
+        Logger: class {
+            info = vi.fn();
+            warn = vi.fn();
+            error = vi.fn();
+            debug = vi.fn();
+        },
+        DataHandler: class {} // Provide a mock DataHandler class
+    };
+});
+
+// Mock Config
+vi.mock('../src/config.js', () => ({
+    Config: {
+        Get: vi.fn((key, defaultValue) => defaultValue)
+    }
+}));
+
+// Mock fs.promises pour contrôler statfs
+vi.mock('node:fs/promises', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        statfs: vi.fn().mockResolvedValue({ bavail: 5000, bsize: 1024, blocks: 10000 }), // Mock de base
+    };
+});
+
+describe('Data Cluster & Gossip Logic', () => {
+    let mockEngine;
+    let postHandlers = {};
+    let mockDataHandler;
+    let mockClusterLeaseModel;
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+
+        // Mock the engine
+        mockEngine = {
+            selfUrl: 'http://node-1:3000',
+            peers: [
+                { id: 'node-1', public_domain: 'http://node-1:3000', sharding: true, replica: true },
+                { id: 'node-2', public_domain: 'http://node-2:3000', sharding: true, replica: true },
+                { id: 'node-3', public_domain: 'http://node-3:3000', sharding: true, replica: true }
+            ],
+            getComponent: vi.fn(componentName => {
+                if (componentName === 'DataHandler') return mockDataHandler;
+                return new Logger('mock');
+            }),
+            sendToPeer: vi.fn(),
+            post: vi.fn((path, handler) => {
+                postHandlers[path] = handler;
+            }),
+        };
+
+        // Mock Mongoose/DataHandler for leasing
+        mockClusterLeaseModel = {
+            findOneAndUpdate: vi.fn(),
+        };
+        mockDataHandler = {
+            mongoose: {
+                Schema: class Schema {},
+                model: vi.fn().mockReturnValue(mockClusterLeaseModel),
+            }
+        };
+
+        // Reset post handlers for each test
+        postHandlers = {};
+    });
+
+    afterEach(() => {
+        stopClusterServices();
+        vi.restoreAllMocks();
+        vi.useRealTimers();
+    });
+
+    describe('Initialization (onInit)', () => {
+        it('should initialize member list from static peer configuration', async () => {
+            await initializeCluster(mockEngine);
+            const memberList = getMemberList();
+
+            expect(memberList).toHaveLength(3);
+            expect(memberList.find(m => m.id === 'node-1')).toBeDefined();
+            expect(memberList.find(m => m.id === 'node-2')).toBeDefined();
+            expect(memberList.find(m => m.id === 'node-3')).toBeDefined();
+
+            const node1 = memberList.find(m => m.id === 'node-1');
+            expect(node1.status).toBe('UP');
+            expect(node1.version).toBe(1);
+        });
+
+        it('should correctly identify selfId', async () => {
+            await initializeCluster(mockEngine);
+            expect(mockEngine.selfId).toBe('node-1');
+        });
+
+        it('should register the /api/internal/gossip endpoint', async () => {
+            await initializeCluster(mockEngine);
+            expect(mockEngine.post).toHaveBeenCalledWith('/api/internal/gossip', expect.any(Function));
+            expect(postHandlers['/api/internal/gossip']).toBeDefined();
+        });
+
+        it('should start the gossip interval', async () => {
+            const setIntervalSpy = vi.spyOn(global, 'setInterval');
+            await initializeCluster(mockEngine);
+            expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 2000); // Default interval
+        });
+    });
+
+    describe('Gossip Execution', () => {
+        it('should send its member list to a random UP peer', async () => {
+            await initializeCluster(mockEngine);
+            mockEngine.sendToPeer.mockResolvedValue({ ok: true, json: () => Promise.resolve([]) });
+
+            await vi.advanceTimersByTimeAsync(2000); // Trigger gossip
+
+            expect(mockEngine.sendToPeer).toHaveBeenCalledTimes(1);
+            const [peerId, path, payload] = mockEngine.sendToPeer.mock.calls[0];
+            expect(['node-2', 'node-3']).toContain(peerId);
+            expect(path).toBe('/api/internal/gossip');
+            expect(payload).toHaveLength(3);
+            expect(payload.find(p => p.id === 'node-1')).toBeDefined();
+        });
+
+        it('should mark a peer as SUSPECT if sendToPeer fails', async () => {
+            await initializeCluster(mockEngine);
+            mockEngine.sendToPeer.mockRejectedValue(new Error('Network error'));
+
+            await vi.advanceTimersByTimeAsync(2000); // Trigger gossip
+
+            expect(mockEngine.sendToPeer).toHaveBeenCalledTimes(1);
+            const failedPeerId = mockEngine.sendToPeer.mock.calls[0][0];
+
+            const memberList = getMemberList();
+            const failedPeer = memberList.find(m => m.id === failedPeerId); 
+            expect(failedPeer.status).toBe('SUSPECT');
+            expect(failedPeer.version).toBe(2); // Version incremented
+        });
+
+        it('should merge the list received from a peer on successful gossip', async () => {
+            const remoteList = [
+                { id: 'node-1', public_domain: 'http://node-1:3000', status: 'UP', version: 1 },
+                { id: 'node-2', public_domain: 'http://node-2:3000', status: 'UP', version: 2 }, // Higher version
+                { id: 'node-4', public_domain: 'http://node-4:3000', status: 'UP', version: 1 }  // New node
+            ];
+            mockEngine.sendToPeer.mockResolvedValue({ ok: true, json: () => Promise.resolve(remoteList) });
+            await initializeCluster(mockEngine);
+
+            await vi.advanceTimersByTimeAsync(2000); // Trigger gossip
+
+            const memberList = getMemberList();
+            expect(memberList).toHaveLength(4);
+            expect(memberList.find(m => m.id === 'node-4')).toBeDefined(); // New node added
+            expect(memberList.find(m => m.id === 'node-2').version).toBe(2); // Node updated
+        });
+    });
+
+    describe('Gossip Health Checks', () => {
+        it('should mark a SUSPECT peer as DOWN after a timeout', async () => {
+            Config.Get.mockImplementation((key, defaultValue) => {
+                if (key === 'gossipSuspectTimeout') return 5000; // 5s timeout for test
+                return defaultValue;
+            });
+
+            // Rendre le choix du pair déterministe en mockant Math.random
+            const randomSpy = vi.spyOn(Math, 'random').mockReturnValue(0);
+
+            await initializeCluster(mockEngine);
+            mockEngine.sendToPeer.mockRejectedValue(new Error('Network error'));
+
+            // Le premier gossip échoue, node-2 devient SUSPECT
+            await vi.advanceTimersByTimeAsync(2000); 
+            const memberListV1 = getMemberList();
+            expect(memberListV1.find(m => m.id === 'node-2')?.status).toBe('SUSPECT');
+
+            // On avance le temps au-delà du timeout + un autre cycle de gossip pour que checkSuspectNodes s'exécute.
+            await vi.advanceTimersByTimeAsync(8000); // 6000ms (timeout) + 2000ms (next gossip)
+
+            const memberListV2 = getMemberList();
+            expect(memberListV2.find(m => m.id === 'node-2')?.status).toBe('DOWN');
+
+            randomSpy.mockRestore(); // Nettoyer le spy
+        });
+    });
+
+    describe('Gossip Endpoint', () => {
+        it('should merge received list and respond with its own updated list', async () => {
+            await initializeCluster(mockEngine);
+            const gossipEndpointHandler = postHandlers['/api/internal/gossip'];
+
+            const remoteList = [
+                { id: 'node-3', public_domain: 'http://node-3:3000', status: 'SUSPECT', version: 5 },
+                { id: 'node-4', public_domain: 'http://node-4:3000', status: 'UP', version: 1 }
+            ];
+            const mockReq = { fields: remoteList };
+            const mockRes = { json: vi.fn() };
+
+            gossipEndpointHandler(mockReq, mockRes);
+
+            // Check if list was merged
+            const memberList = getMemberList();
+            expect(memberList).toHaveLength(4);
+            expect(memberList.find(m => m.id === 'node-4')).toBeDefined();
+            expect(memberList.find(m => m.id === 'node-3').status).toBe('SUSPECT');
+            expect(memberList.find(m => m.id === 'node-3').version).toBe(5);
+
+            // Check if it responded with the new list
+            expect(mockRes.json).toHaveBeenCalledWith(memberList);
+        });
+    });
+
+});

package/test/core.test.js

@@ -1,6 +1,4 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
 import {
     sleep,
     escapeRegex,

package/test/replication.test.js

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { queueReplication, onInit, stopReplicationQueue } from '../src/modules/data/data.replication.js';
+import * as clusterModule from '../src/modules/data/data.cluster.js';
+import { Logger } from "../src/index.js"
+
+// Mock Logger to prevent console output
+vi.mock('../src/gameObject.js', () => ({
+    Logger: class {
+        info = vi.fn();
+        warn = vi.fn();
+        error = vi.fn();
+        debug = vi.fn();
+    }
+}));
+
+describe('Data Replication Logic', () => {
+    let mockEngine;
+    let getReplicaNodesForUserSpy;
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+
+        // Mock the engine and its sendToPeer function
+        mockEngine = {
+            peers: [
+                { id: 'self', url: 'http://self:3000' },
+                { id: 'replica-1', url: 'http://replica-1:3000' },
+                { id: 'replica-2', url: 'http://replica-2:3000' }
+            ],
+            getComponent: vi.fn().mockReturnValue(new Logger('mock')),
+            sendToPeer: vi.fn().mockResolvedValue({ ok: true }),
+        };
+
+        // Spy on getReplicaNodesForUser to control its output
+        getReplicaNodesForUserSpy = vi.spyOn(clusterModule, 'getReplicaNodesForUser');
+
+        // Initialize the replication module with the mock engine
+        onInit(mockEngine);
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+        stopReplicationQueue();
+        // Clear the queue manually for test isolation
+        const replicationQueue = []; // This is a simplified way to clear it for tests
+        while (replicationQueue.length > 0) {
+            replicationQueue.pop();
+        }
+    });
+
+    it('should queue an operation correctly', async () => {
+        const operation = 'insert';
+        const modelName = 'testModel';
+        const user = { username: 'testuser' };
+        const payload = { data: { name: 'test' } };
+
+        // This test is tricky because replicationQueue is not exported.
+        // We'll test its effect indirectly via processReplicationQueue.
+        queueReplication(operation, modelName, user, payload);
+
+        // We can't directly inspect the queue, so we'll let the processing logic run
+        // and check if the mocks were called.
+        getReplicaNodesForUserSpy.mockReturnValue([{ id: 'replica-1' }]);
+
+        await vi.advanceTimersByTimeAsync(200); // Advance time to trigger processReplicationQueue
+
+        // Check that the processing function tried to get replicas
+        expect(getReplicaNodesForUserSpy).toHaveBeenCalledWith(user.username);
+    });
+
+    it('should process the queue and send operations in batches to correct replicas', async () => {
+        const user1 = { username: 'user1' };
+        const user2 = { username: 'user2' };
+
+        // Mock so user1 replicates to replica-1 and user2 to replica-2
+        getReplicaNodesForUserSpy.mockImplementation((username) => {
+            if (username === 'user1') return [{ id: 'replica-1' }];
+            if (username === 'user2') return [{ id: 'replica-2' }];
+            return [];
+        });
+
+        // Queue operations for different users
+        queueReplication('insert', 'modelA', user1, { data: { a: 1 } });
+        queueReplication('update', 'modelB', user2, { data: { b: 2 } });
+        queueReplication('delete', 'modelC', user1, { ids: ['123'] });
+
+        // Advance timers to trigger the processing
+        await vi.advanceTimersByTimeAsync(200);
+
+        // Assertions
+        expect(mockEngine.sendToPeer).toHaveBeenCalledTimes(2);
+
+        // Check call for replica-1
+        expect(mockEngine.sendToPeer).toHaveBeenCalledWith(
+            'replica-1',
+            '/api/internal/replicate',
+            expect.objectContaining({
+                operations: expect.arrayContaining([
+                    expect.objectContaining({ operation: 'insert', modelName: 'modelA', user: user1 }),
+                    expect.objectContaining({ operation: 'delete', modelName: 'modelC', user: user1 })
+                ])
+            })
+        );
+
+        // Check call for replica-2
+        expect(mockEngine.sendToPeer).toHaveBeenCalledWith(
+            'replica-2',
+            '/api/internal/replicate',
+            expect.objectContaining({
+                operations: expect.arrayContaining([
+                    expect.objectContaining({ operation: 'update', modelName: 'modelB', user: user2 })
+                ])
+            })
+        );
+    });
+
+    it('should not process queue if CLUSTER_SHARED_DATABASE is true', async () => {
+        process.env.CLUSTER_SHARED_DATABASE = 'true';
+
+        queueReplication('insert', 'modelA', { username: 'user1' }, { data: { a: 1 } });
+
+        await vi.advanceTimersByTimeAsync(200);
+
+        expect(mockEngine.sendToPeer).not.toHaveBeenCalled();
+
+        delete process.env.CLUSTER_SHARED_DATABASE; // Cleanup
+    });
+
+    it('should queue a failed batch for retry and re-send it on the next cycle', async () => {
+        const user = { username: 'retry-user' };
+        const payload = { data: { name: 'important-data' } };
+
+        // Configurer le mock pour qu'il échoue la première fois et réussisse la seconde
+        mockEngine.sendToPeer
+            .mockRejectedValueOnce(new Error('Simulated Network Error'))
+            .mockResolvedValue({ ok: true });
+
+        // Toutes les opérations pour cet utilisateur vont vers 'replica-1'
+        getReplicaNodesForUserSpy.mockReturnValue([{ id: 'replica-1' }]);
+
+        // 1. Mettre une opération en file d'attente
+        queueReplication('insert', 'retryModel', user, payload);
+
+        // 2. Premier cycle : processReplicationQueue est appelé, sendToPeer échoue
+        // Advance just enough to trigger one processing cycle (assuming interval is 100ms)
+        await vi.advanceTimersByTimeAsync(100);
+
+        // Vérifier que l'échec a été loggué et que la tentative a eu lieu
+        expect(mockEngine.sendToPeer).toHaveBeenCalledTimes(1);
+
+        // 3. Deuxième cycle : retryFailedBatches est appelé, sendToPeer réussit
+        await vi.advanceTimersByTimeAsync(100);
+
+        // Vérifier que la nouvelle tentative a eu lieu
+        expect(mockEngine.sendToPeer).toHaveBeenCalledTimes(2);
+
+        // Vérifier que les deux appels étaient pour la même réplique avec les mêmes données
+        const firstCallArgs = mockEngine.sendToPeer.mock.calls[0];
+        const secondCallArgs = mockEngine.sendToPeer.mock.calls[1];
+        expect(firstCallArgs).toEqual(secondCallArgs);
+    });
+});

package/doc/core-concepts.md

@@ -1,33 +0,0 @@
-# Core Concepts: Data Modeling Fundamentals
-
-The `data-primals-engine` is built around a flexible and powerful data modeling system that allows you to define and manage your application's data structures without complex migrations. This section introduces the fundamental concepts of data modeling within the engine.
-
-## Dynamic and Schema-less Nature
-
-At its core, `data-primals-engine` leverages **MongoDB**, a NoSQL database. This provides inherent flexibility, allowing for a schema-less approach. You can define and update your data models either through a user interface or by providing JSON definitions, and the system adapts dynamically without requiring traditional database migrations. This significantly accelerates development and iteration cycles.
-
-## Models
-
-A **Model** is the blueprint for a collection of data. It defines the structure and characteristics of the documents you store. For example, a `User` model would define what properties a user object has (e.g., `username`, `email`, `roles`).
-
-Models are defined by a `name`, an optional `description`, an `icon`, and a list of `fields`. The engine comes with a set of default models for common entities like `user`, `product`, `workflow`, and more.
-
-## Fields
-
-**Fields** are the individual attributes that make up a model. Each field has a `name`, a `type`, and various optional properties that define its behavior and constraints.
-
-Common field types include:
--   `string`: For text data.
--   `number`: For numerical data.
--   `boolean`: For true/false values.
--   `datetime`: For date and time values.
--   `relation`: To establish relationships between different models (e.g., a `product` model having a `category` field that relates to a `taxonomy` model).
--   `enum`: For fields with a predefined set of allowed values.
--   `file`: For handling file uploads (e.g., `profilePicture` in the `user` model).
--   `code`: For storing code snippets (e.g., `script` in an `endpoint` model).
-
-Fields can also have properties like `required`, `unique`, `min`, `max`, `default` values, and `hint` for user guidance.
-
-This dynamic and field-based approach to data modeling provides the flexibility needed for rapidly building complex data-driven applications.
-
-**Next: Data Models**