data-primals-engine 1.5.1 → 1.6.0

package/src/sso.js

@@ -1,194 +1,194 @@
-import passport from 'passport';
-import session from 'express-session';
-import { Behaviour } from './gameObject.js';
-import { cookiesSecret } from "./constants.js";
-import {UserProvider} from "./providers.js";
-import {getCollection} from "./modules/mongodb.js";
-import process from "process";
-
-/**
- * @class SSOUserProvider
- * Gère les utilisateurs provenant de fournisseurs d'identité externes (SSO).
- * Sa responsabilité principale est de trouver un utilisateur existant correspondant
- * au profil SSO ou d'en créer un nouveau si nécessaire (provisioning à la volée).
- */
-export class SSOUserProvider extends UserProvider {
-
-    usersCollection;
-
-    constructor(engine) {
-        super(engine);
-        // Idéalement, la collection d'utilisateurs devrait être centralisée.
-        // Pour cet exemple, nous la récupérons directement.
-        this.usersCollection = getCollection("users"); // Assurez-vous que cette collection existe
-    }
-
-    /**
-     * Trouve un utilisateur par son ID. Nécessaire pour la désérialisation de Passport.
-     * @param {string} id - L'ID de l'utilisateur.
-     * @returns {Promise<object|null>}
-     */
-    async findUserById(id) {
-        // Note: Assurez-vous que vos utilisateurs ont un champ `_id` stable.
-        // Si vous utilisez le `username` comme identifiant principal, adaptez cette méthode.
-        try {
-            const { ObjectId } = await import('mongodb');
-            return await this.usersCollection.findOne({ _id: new ObjectId(id) });
-        } catch (e) {
-            return null; // Gère le cas où l'ID n'est pas un ObjectId valide
-        }
-    }
-
-    /**
-     * La méthode clé pour l'intégration SSO.
-     * Cherche un utilisateur basé sur le profil fourni par le fournisseur d'identité.
-     * S'il n'existe pas, il le crée.
-     * @param {object} profile - Le profil utilisateur de Passport (ex: de Google, SAML).
-     * @returns {Promise<object>} L'utilisateur de votre système.
-     */
-    async findOrCreate(profile) {
-        if (!profile.emails || !profile.emails[0] || !profile.emails[0].value) {
-            throw new Error("Le profil du fournisseur d'identité ne contient pas d'email.");
-        }
-
-        const email = profile.emails[0].value;
-
-        // 1. Chercher un utilisateur existant avec cet email.
-        const existingUser = await this.usersCollection.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;
-        }
-
-        // 2. Si aucun utilisateur n'est trouvé, en créer un nouveau.
-        const newUser = {
-            username: email, // Utiliser l'email comme nom d'utilisateur par défaut
-            email: email,
-            name: profile.displayName || email,
-            provider: profile.provider, // ex: 'google', 'saml'
-            providerId: profile.id,
-            userPlan: 'free', // Assigner un plan par défaut
-            createdAt: new Date()
-        };
-
-        const result = await this.usersCollection.insertOne(newUser);
-        return await this.findUserById(result.insertedId);
-    }
-
-    // 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 */ }
-}
-
-/**
- * @class Sso
- * @extends Behaviour
- * Un composant réutilisable qui encapsule la logique de Passport.js pour l'authentification.
- * Il gère la session, la sérialisation, et permet à d'autres modules d'enregistrer
- * dynamiquement des stratégies d'authentification (Google, SAML, etc.).
- */
-export class Sso extends Behaviour {
-    #ssoUserProvider = null;
-    #logger = null;
-
-    constructor(gameObject) {
-        super(gameObject);
-        this.strategies = new Map();
-    }
-
-    /**
-     * Initialise le composant avec les middlewares et la configuration de base de Passport.
-     * @param {object} options
-     * @param {UserProvider} options.ssoUserProvider - Le provider pour trouver ou créer des utilisateurs SSO.
-     */
-    initialize({ ssoUserProvider }) {
-        if (!ssoUserProvider) {
-            throw new Error("PassportAuth component requires an ssoUserProvider to be initialized.");
-        }
-        this.#ssoUserProvider = ssoUserProvider;
-        this.#logger = this.gameObject.getComponent('Logger'); // Assumant que Logger est un composant
-
-        const app = this.gameObject; // this.gameObject est l'instance de l'engine (Express app)
-
-        // 1. Configurer la session Express (prérequis pour Passport)
-        app.use(session({
-            secret: process.env.COOKIES_SECRET || cookiesSecret,
-            resave: false,
-            saveUninitialized: false,
-            cookie: { secure: process.env.NODE_ENV === 'production', httpOnly: true, sameSite: 'lax' }
-        }));
-
-        // 2. Initialiser Passport
-        app.use(passport.initialize());
-        app.use(passport.session());
-
-        // 3. Configurer la sérialisation/désérialisation
-        passport.serializeUser((user, done) => {
-            done(null, user._id);
-        });
-
-        passport.deserializeUser(async (id, done) => {
-            try {
-                const user = await this.#ssoUserProvider.findUserById(id);
-                done(null, user);
-            } catch (err) {
-                done(err);
-            }
-        });
-
-        this.#logger.info("PassportAuth component initialized successfully.");
-    }
-
-    /**
-     * Permet à d'autres modules d'enregistrer une nouvelle stratégie d'authentification.
-     * @param {string} name - Le nom de la stratégie (ex: 'google', 'saml').
-     * @param {object} strategy - L'instance de la stratégie Passport.
-     * @param {object} routes - Les chemins pour l'authentification.
-     * @param {string} routes.authPath - Le chemin pour initier l'authentification (ex: '/api/auth/google').
-     * @param {string} routes.callbackPath - Le chemin de callback (ex: '/api/auth/google/callback').
-     * @param {object} options - Options d'authentification pour Passport (ex: { scope: ['profile', 'email'] }).
-     */
-    addStrategy(name, strategy, routes, options = {}) {
-        if (this.strategies.has(name)) {
-            this.#logger.warn(`Passport strategy '${name}' is already registered. Overwriting.`);
-        }
-
-        // Enregistrer la stratégie auprès de Passport
-        passport.use(strategy);
-
-        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;
-            }
-        );
-
-        this.strategies.set(name, { strategy, routes, options });
-        this.#logger.info(`Passport strategy '${name}' registered with routes: ${routes.authPath}, ${routes.callbackPath}`);
-    }
-
-    addLogoutRoute(path = '/api/auth/logout') {
-        this.gameObject.get(path, (req, res, next) => {
-            req.logout((err) => {
-                if (err) { return next(err); }
-                req.session.destroy(() => {
-                    res.redirect('/');
-                });
-            });
-        });
-        this.#logger.info(`Logout route registered at '${path}'.`);
-    }
+import passport from 'passport';
+import session from 'express-session';
+import {Behaviour, Logger} from './gameObject.js';
+import { cookiesSecret } from "./constants.js";
+import {UserProvider} from "./providers.js";
+import {getCollection} from "./modules/mongodb.js";
+import process from "process";
+
+/**
+ * @class SSOUserProvider
+ * Gère les utilisateurs provenant de fournisseurs d'identité externes (SSO).
+ * Sa responsabilité principale est de trouver un utilisateur existant correspondant
+ * au profil SSO ou d'en créer un nouveau si nécessaire (provisioning à la volée).
+ */
+export class SSOUserProvider extends UserProvider {
+
+    usersCollection;
+
+    constructor(engine) {
+        super(engine);
+        // Idéalement, la collection d'utilisateurs devrait être centralisée.
+        // Pour cet exemple, nous la récupérons directement.
+        this.usersCollection = getCollection("users"); // Assurez-vous que cette collection existe
+    }
+
+    /**
+     * Trouve un utilisateur par son ID. Nécessaire pour la désérialisation de Passport.
+     * @param {string} id - L'ID de l'utilisateur.
+     * @returns {Promise<object|null>}
+     */
+    async findUserById(id) {
+        // Note: Assurez-vous que vos utilisateurs ont un champ `_id` stable.
+        // Si vous utilisez le `username` comme identifiant principal, adaptez cette méthode.
+        try {
+            const { ObjectId } = await import('mongodb');
+            return await this.usersCollection.findOne({ _id: new ObjectId(id) });
+        } catch (e) {
+            return null; // Gère le cas où l'ID n'est pas un ObjectId valide
+        }
+    }
+
+    /**
+     * La méthode clé pour l'intégration SSO.
+     * Cherche un utilisateur basé sur le profil fourni par le fournisseur d'identité.
+     * S'il n'existe pas, il le crée.
+     * @param {object} profile - Le profil utilisateur de Passport (ex: de Google, SAML).
+     * @returns {Promise<object>} L'utilisateur de votre système.
+     */
+    async findOrCreate(profile) {
+        if (!profile.emails || !profile.emails[0] || !profile.emails[0].value) {
+            throw new Error("Le profil du fournisseur d'identité ne contient pas d'email.");
+        }
+
+        const email = profile.emails[0].value;
+
+        // 1. Chercher un utilisateur existant avec cet email.
+        const existingUser = await this.usersCollection.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;
+        }
+
+        // 2. Si aucun utilisateur n'est trouvé, en créer un nouveau.
+        const newUser = {
+            username: email, // Utiliser l'email comme nom d'utilisateur par défaut
+            email: email,
+            name: profile.displayName || email,
+            provider: profile.provider, // ex: 'google', 'saml'
+            providerId: profile.id,
+            userPlan: 'free', // Assigner un plan par défaut
+            createdAt: new Date()
+        };
+
+        const result = await this.usersCollection.insertOne(newUser);
+        return await this.findUserById(result.insertedId);
+    }
+
+    // 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 */ }
+}
+
+/**
+ * @class Sso
+ * @extends Behaviour
+ * Un composant réutilisable qui encapsule la logique de Passport.js pour l'authentification.
+ * Il gère la session, la sérialisation, et permet à d'autres modules d'enregistrer
+ * dynamiquement des stratégies d'authentification (Google, SAML, etc.).
+ */
+export class Sso extends Behaviour {
+    #ssoUserProvider = null;
+    #logger = null;
+
+    constructor(gameObject) {
+        super(gameObject);
+        this.strategies = new Map();
+    }
+
+    /**
+     * Initialise le composant avec les middlewares et la configuration de base de Passport.
+     * @param {object} options
+     * @param {UserProvider} options.ssoUserProvider - Le provider pour trouver ou créer des utilisateurs SSO.
+     */
+    initialize({ ssoUserProvider }) {
+        if (!ssoUserProvider) {
+            throw new Error("PassportAuth component requires an ssoUserProvider to be initialized.");
+        }
+        this.#ssoUserProvider = ssoUserProvider;
+        this.#logger = this.gameObject.getComponent(Logger); // Assumant que Logger est un composant
+
+        const app = this.gameObject; // this.gameObject est l'instance de l'engine (Express app)
+
+        // 1. Configurer la session Express (prérequis pour Passport)
+        app.use(session({
+            secret: process.env.COOKIES_SECRET || cookiesSecret,
+            resave: false,
+            saveUninitialized: false,
+            cookie: { secure: process.env.NODE_ENV === 'production', httpOnly: true, sameSite: 'lax' }
+        }));
+
+        // 2. Initialiser Passport
+        app.use(passport.initialize());
+        app.use(passport.session());
+
+        // 3. Configurer la sérialisation/désérialisation
+        passport.serializeUser((user, done) => {
+            done(null, user._id);
+        });
+
+        passport.deserializeUser(async (id, done) => {
+            try {
+                const user = await this.#ssoUserProvider.findUserById(id);
+                done(null, user);
+            } catch (err) {
+                done(err);
+            }
+        });
+
+        this.#logger.info("PassportAuth component initialized successfully.");
+    }
+
+    /**
+     * Permet à d'autres modules d'enregistrer une nouvelle stratégie d'authentification.
+     * @param {string} name - Le nom de la stratégie (ex: 'google', 'saml').
+     * @param {object} strategy - L'instance de la stratégie Passport.
+     * @param {object} routes - Les chemins pour l'authentification.
+     * @param {string} routes.authPath - Le chemin pour initier l'authentification (ex: '/api/auth/google').
+     * @param {string} routes.callbackPath - Le chemin de callback (ex: '/api/auth/google/callback').
+     * @param {object} options - Options d'authentification pour Passport (ex: { scope: ['profile', 'email'] }).
+     */
+    addStrategy(name, strategy, routes, options = {}) {
+        if (this.strategies.has(name)) {
+            this.#logger.warn(`Passport strategy '${name}' is already registered. Overwriting.`);
+        }
+
+        // Enregistrer la stratégie auprès de Passport
+        passport.use(strategy);
+
+        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;
+            }
+        );
+
+        this.strategies.set(name, { strategy, routes, options });
+        this.#logger.info(`Passport strategy '${name}' registered with routes: ${routes.authPath}, ${routes.callbackPath}`);
+    }
+
+    addLogoutRoute(path = '/api/auth/logout') {
+        this.gameObject.get(path, (req, res, next) => {
+            req.logout((err) => {
+                if (err) { return next(err); }
+                req.session.destroy(() => {
+                    res.redirect('/');
+                });
+            });
+        });
+        this.#logger.info(`Logout route registered at '${path}'.`);
+    }
 }

package/src/workers/import-export-worker.js

@@ -1,5 +1,5 @@
 import { parentPort } from 'worker_threads';
-import { parse } from 'csv-parse/sync'; // On utilise la version synchrone, c'est ok dans un worker
+import { parse } from 'csv-parse/sync';
 
 parentPort.on('message', ({ action, payload }) => {
     try {

package/test/data.history.integration.test.js

@@ -1,6 +1,7 @@
 // __tests__/data.history.integration.test.js
 import { ObjectId } from 'mongodb';
 import { expect, describe, it, beforeAll, afterAll, beforeEach } from 'vitest';
+import { handleGetHistoryRequest } from '../src/modules/data/data.history.js';
 import { Config } from '../src/config.js';
 import { sleep } from '../src/core.js';
 import { insertData, editData, deleteModels } from '../src/index.js';
@@ -190,4 +191,75 @@ describe('Data History Module Integration Tests', () => {
         const historyCount = await historyCollection.countDocuments({ documentId: docId });
         expect(historyCount).toBe(1);
     });
+
+    it('should filter history records by date range', async () => {
+        // 1. Setup model
+        const modelName = generateUniqueName('productHistoryDateFilter');
+        const productModelDef = {
+            name: modelName,
+            description: "",
+            _user: testUser.username,
+            history: { enabled: true },
+            fields: [{ name: 'name', type: 'string' }]
+        };
+        await modelsCollection.insertOne(productModelDef);
+
+        // 2. Insert initial document
+        const insertResult = await insertData(modelName, { name: 'Time-traveling Widget' }, {}, testUser);
+        const docId = new ObjectId(insertResult.insertedIds[0]);
+
+        // 3. Create history entries at different times
+        // To simulate different timestamps, we'll manually insert history records
+        // as editData() would create them too close together in time.
+        await historyCollection.updateOne({ documentId: docId, version: 1 }, { $set: { timestamp: new Date('2023-01-10T10:00:00Z') } });
+
+        await historyCollection.insertOne({
+            documentId: docId, model: modelName, version: 2, operation: 'update',
+            timestamp: new Date('2023-02-15T12:00:00Z'), user: { username: testUser.username }, changes: { name: { from: 'v1', to: 'v2' } }
+        });
+        await historyCollection.insertOne({
+            documentId: docId, model: modelName, version: 3, operation: 'update',
+            timestamp: new Date('2023-02-20T14:00:00Z'), user: { username: testUser.username }, changes: { name: { from: 'v2', to: 'v3' } }
+        });
+        await historyCollection.insertOne({
+            documentId: docId, model: modelName, version: 4, operation: 'update',
+            timestamp: new Date('2023-03-05T16:00:00Z'), user: { username: testUser.username }, changes: { name: { from: 'v3', to: 'v4' } }
+        });
+
+        // Mock Express req/res objects
+        const mockReq = (query) => ({
+            params: { modelName, recordId: docId.toString() },
+            query,
+            me: testUser
+        });
+        const mockRes = () => {
+            const res = {};
+            res.status = (code) => { res.statusCode = code; return res; };
+            res.json = (data) => { res.body = data; return res; };
+            return res;
+        };
+
+        // 4. Test cases
+        // Case A: Filter for February
+        let req = mockReq({ startDate: '2023-02-01', endDate: '2023-02-28' });
+        let res = mockRes();
+        await handleGetHistoryRequest(req, res);
+        expect(res.body.success).toBe(true);
+        expect(res.body.count).toBe(2);
+        expect(res.body.data.map(d => d._v).sort()).toEqual([2, 3]);
+
+        // Case B: Filter starting from Feb 15th
+        req = mockReq({ startDate: '2023-02-15' });
+        res = mockRes();
+        await handleGetHistoryRequest(req, res);
+        expect(res.body.success).toBe(true);
+        expect(res.body.count).toBe(3); // v2, v3, v4
+
+        // Case C: Filter up to Feb 15th (inclusive)
+        req = mockReq({ endDate: '2023-02-15' });
+        res = mockRes();
+        await handleGetHistoryRequest(req, res);
+        expect(res.body.success).toBe(true);
+        expect(res.body.count).toBe(2); // v1, v2
+    });
 });

package/test/data.integration.test.js

@@ -130,7 +130,7 @@ async function setupTestContext() {
 }
 
 let engine;
-describe('Intégration des fonctions CRUD de données avec validation complète', () => {
+describe('Data integration tests (CRUD, validation...)', () => {
 
     beforeAll(async () =>{
         Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
@@ -543,6 +543,97 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
         // TODO: Ajouter plus de tests de validation pour editData, similaires à ceux de insertData
     });
 
+    describe('$push operation using patchData', () =>{
+        describe('$push sur tableau existant', () => {
+            let docToPatchId;
+            let setupContext;
+
+            beforeEach(async () => {
+                setupContext = await setupTestContext();
+                const { currentTestUser, comprehensiveTestModelDefinition } = setupContext;
+
+                const initialData = {
+                    stringRequired: 'InitialForPush',
+                    stringUnique: 'UniqueForPush',
+                    enumField: 'alpha',
+                    passwordField: 'pushPass',
+                    arrayString: ['tag1'],
+                    arrayNumber: [100]
+                };
+                const insertResult = await insertData(comprehensiveTestModelDefinition.name, initialData, {}, currentTestUser, false);
+                docToPatchId = insertResult.insertedIds[0];
+            });
+
+            afterEach(async () => {
+                await setupContext.purge();
+            });
+
+            it('devrait ajouter une seule valeur à un tableau existant', async () => {
+                const { currentTestUser, comprehensiveTestModelDefinition } = setupContext;
+
+                const result = await patchData(comprehensiveTestModelDefinition.name, { _id: docToPatchId }, { arrayString: { $push: 'tag2' } }, {}, currentTestUser);
+
+                expect(result.success, `patchData avec $push a échoué: ${result.error}`).toBe(true);
+                expect(result.modifiedCount).toBe(1);
+
+                const patchedDoc = await testDatasColInstance.findOne({ _id: new ObjectId(docToPatchId) });
+                expect(patchedDoc.arrayString).toEqual(['tag1', 'tag2']);
+            });
+
+            it('devrait ajouter plusieurs valeurs à un tableau existant', async () => {
+                const { currentTestUser, comprehensiveTestModelDefinition } = setupContext;
+
+                const result = await patchData(comprehensiveTestModelDefinition.name, { _id: docToPatchId }, { arrayNumber: { $push: [200, 300] } }, {}, currentTestUser);
+
+                expect(result.success, `patchData avec $push multiple a échoué: ${result.error}`).toBe(true);
+                expect(result.modifiedCount).toBe(1);
+
+                const patchedDoc = await testDatasColInstance.findOne({ _id: new ObjectId(docToPatchId) });
+                expect(patchedDoc.arrayNumber).toEqual([100, 200, 300]);
+            });
+
+            it('devrait rejeter un push si la valeur est invalide', async () => {
+                const { currentTestUser, comprehensiveTestModelDefinition } = setupContext;
+
+                // Tenter de pusher un nombre dans un tableau de strings
+                const result = await patchData(comprehensiveTestModelDefinition.name, { _id: docToPatchId }, { arrayString: { $push: 12345 } }, {}, currentTestUser);
+
+                expect(result.success).toBe(false);
+                expect(result.error).toContain("Valeur invalide fournie pour le tableau 'arrayString'");
+            });
+
+            it('devrait rejeter un push si une des valeurs du tableau est invalide', async () => {
+                const { currentTestUser, comprehensiveTestModelDefinition } = setupContext;
+
+                // Tenter de pusher un tableau contenant une valeur invalide
+                const result = await patchData(comprehensiveTestModelDefinition.name, { _id: docToPatchId }, { arrayNumber: { $push: [400, 'not-a-number', 500] } }, {}, currentTestUser);
+
+                expect(result.success).toBe(false);
+                expect(result.error).toContain("Valeur invalide fournie pour le tableau 'arrayNumber'");
+            });
+
+        });
+        describe('$push sur un tableau inexistant', () => {
+            it('devrait créer le tableau et pusher les valeurs s\'il n\'existe pas', async () => {
+            // On utilise un setup de contexte complètement isolé pour ce test
+                const { currentTestUser, comprehensiveTestModelDefinition, purge } = await setupTestContext();
+
+                const initialData = { stringRequired: 'NoArrayField', stringUnique: 'UniqueForNoArrayPush', enumField: 'beta', passwordField: 'pass' };
+                const insertResult = await insertData(comprehensiveTestModelDefinition.name, initialData, {}, currentTestUser, false);
+                const newDocId = insertResult.insertedIds[0];
+
+                const result = await patchData(comprehensiveTestModelDefinition.name, { _id: newDocId }, { arrayString: { $push: ['first', 'second'] } }, {}, currentTestUser);
+
+                expect(result.success, `patchData sur un tableau inexistant a échoué: ${result.error}`).toBe(true);
+                expect(result.modifiedCount).toBe(1);
+
+                const patchedDoc = await testDatasColInstance.findOne({ _id: new ObjectId(newDocId) });
+                expect(patchedDoc.arrayString).toEqual(['first', 'second']);
+                await purge();
+            });
+        });
+    });
+
     // --- Tests deleteData (repris de votre exemple, peuvent être gardés tels quels ou adaptés) ---
     describe('deleteData (tests existants)', () => {
         it('supprimer des données par ID (deleteData)', async () => {