data-primals-engine 1.4.0 → 1.4.2

package/src/providers.js

@@ -1,5 +1,7 @@
-import {compare} from "bcrypt";
+import {compare, hash} from "bcrypt";
 import {maxTotalPrivateFilesSize} from "./constants.js";
+import {getCollection, ObjectId} from "./modules/mongodb.js";
+import {Logger} from "./gameObject.js";
 
 /**
  * @class UserProvider
@@ -18,6 +20,16 @@ export class UserProvider {
         this.plans = this.getUserPlans();
     }
 
+    /**
+     * Trouve un utilisateur par son ID unique. Nécessaire pour la désérialisation de Passport.
+     * @param {string} id - L'ID de l'utilisateur.
+     * @returns {Promise<object|null>} L'objet utilisateur ou null.
+     */
+    async findUserById(id) {
+        throw new Error("Method 'findUserById()' must be implemented.");
+    }
+
+
     /**
      * Met à jour un nouvel utilisateur.
      * @param user
@@ -171,4 +183,101 @@ export class DefaultUserProvider extends UserProvider {
             }
         }
     }
+}
+
+/**
+ * @class MongoUserProvider
+ * Un fournisseur d'utilisateurs prêt pour la production qui stocke les utilisateurs
+ * dans MongoDB et gère les mots de passe de manière sécurisée avec bcrypt.
+ */
+export class MongoUserProvider extends UserProvider {
+    constructor(engine) {
+        super(engine);
+        this.usersCollection = getCollection("users");
+        this.logger = engine.getComponent(Logger);
+        this.logger.info("MongoUserProvider initialized, using 'users' collection for local accounts.");
+    }
+
+    /**
+     * Trouve un utilisateur par son ID MongoDB.
+     * @param {string} id - L'ID de l'utilisateur.
+     * @returns {Promise<object|null>}
+     */
+    async findUserById(id) {
+        try {
+            if (!ObjectId.isValid(id)) return null;
+            // On exclut le mot de passe des requêtes pour des raisons de sécurité
+            return await this.usersCollection.findOne({ _id: new ObjectId(id) }, { projection: { password: 0 } });
+        } catch (e) {
+            this.logger.error(`Error in findUserById: ${e.message}`);
+            return null;
+        }
+    }
+
+    /**
+     * Trouve un utilisateur par son nom d'utilisateur ou son email.
+     * @param {string} username - Le nom d'utilisateur ou l'email.
+     * @returns {Promise<object|null>}
+     */
+    async findUserByUsername(username) {
+        // Permet de se connecter avec l'username ou l'email
+        return await this.usersCollection.findOne({ $or: [{ username }, { email: username }] });
+    }
+
+    /**
+     * Valide le mot de passe fourni par rapport au hash stocké.
+     * @param {object} user - L'objet utilisateur complet (avec le hash du mot de passe).
+     * @param {string} password - Le mot de passe en clair à vérifier.
+     * @returns {Promise<boolean>}
+     */
+    async validatePassword(user, password) {
+        if (!user || !user.password || !password) {
+            return false;
+        }
+        return await compare(password, user.password);
+    }
+
+    /**
+     * Crée un nouvel utilisateur avec un mot de passe haché.
+     * @param {object} userData - Données de l'utilisateur (username, email, password, etc.).
+     * @returns {Promise<object>} L'utilisateur nouvellement créé (sans le mot de passe).
+     */
+    async createUser(userData) {
+        const { username, email, password, ...otherData } = userData;
+        if (!username || !email || !password) {
+            throw new Error("Username, email, and password are required to create a user.");
+        }
+
+        const existingUser = await this.usersCollection.findOne({ $or: [{ username }, { email }] });
+        if (existingUser) {
+            throw new Error("User with this username or email already exists.");
+        }
+
+        const hashedPassword = await hash(password, 12);
+
+        const result = await this.usersCollection.insertOne({
+            username,
+            email,
+            password: hashedPassword,
+            createdAt: new Date(),
+            userPlan: 'free', // Plan par défaut
+            ...otherData
+        });
+
+        return await this.findUserById(result.insertedId);
+    }
+
+    /**
+     * Initialise l'utilisateur sur la requête à partir de la session.
+     * Ne gère que les utilisateurs locaux. Le SSO est géré par Passport.
+     * @param {object} req - L'objet requête Express.
+     */
+    async initiateUser(req) {
+        if (req.session?.user?._id) {
+            const user = await this.findUserById(req.session.user._id);
+            if (user) {
+                req.me = user; // Attache l'utilisateur à la requête
+            }
+        }
+    }
 }

package/src/services/stripe.js

@@ -1,6 +1,7 @@
 import Stripe from 'stripe';
 import {editData, insertData, searchData} from '../modules/data/index.js';
 import {getEnv} from "../modules/user.js";
+import {safeAssignObject} from "../core.js";
 
 const stripeInstances = {};
 
@@ -15,10 +16,10 @@ async function getStripeClient(user) {
     if (!stripeInstances[userId]) {
         const env = await getEnv(user);
         if (env.STRIPE_SECRET_KEY) {
-            stripeInstances[userId] = {
+            safeAssignObject(stripeInstances, userId, {
                 client: new Stripe(env.STRIPE_SECRET_KEY),
                 webhookSecret: env.STRIPE_WEBHOOK_SECRET
-            };
+            });
         }
     }
     return stripeInstances[userId] || null;

package/src/sso.js

@@ -0,0 +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}'.`);
+    }
+}

package/test/data.integration.test.js

@@ -699,6 +699,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
             // 1. Définir le pack de données mock
             const mockPack = {
+                private: false,
                 name: 'test-pack-for-install',
                 models: [
                     {
@@ -774,6 +775,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
             const mockPackWithInvalidModel = {
                 name: 'invalid-model-pack',
+                private: false,
                 models: [
                     {
                         // 'name' est requis, on l'omet pour causer une erreur
@@ -816,6 +818,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             // 1. Définir le pack avec des données JSON
             const mockPackWithJson = {
                 name: 'test-pack-with-json',
+                private: false,
                 models: [
                     {
                         name: 'packConfig',

package/test/user.test.js

@@ -66,7 +66,7 @@ describe('User Permission Logic', () => {
 
     // --- SETUP : Création des données de test avant tous les tests ---
     beforeAll(async () => {
-        Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
+        Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant", "auth-google", "auth-saml", "auth-microsoft"]);
         engine = await initEngine();
 
     });