data-primals-engine 1.2.0 → 1.2.2

package/src/modules/file.js

@@ -13,9 +13,12 @@ import crypto from "node:crypto";
 import * as tar from "tar";
 import {promisify} from "node:util";
 import {calculateTotalUserStorageUsage, hasPermission} from "./user.js";
+import {Logger} from "../gameObject.js";
+import {deleteFromS3, getUserS3Config, uploadToS3} from "./bucket.js";
 
 const pbkdf2Async = promisify(crypto.pbkdf2);
 
+let engine, logger;
 const fsPromises = fs.promises;
 
 // Encryption settings
@@ -64,78 +67,116 @@ export const addFile = async (file, user) => {
         throw new Error(i18n.t("api.data.serverStorageFull", "Le serveur a atteint sa capacité de stockage maximale. Veuillez réessayer plus tard."));
     }
 
-    const collection = getCollection("files");
-
     // Générer un GUID pour le fichier
     const guid = uuidv4();
-    const filename = guid + path.extname(file.originalname || file.name); // Préserver l'extension
-    const filepath = path.join(process.cwd(), 'uploads', 'private', filename);
-
-    try {
-        // Enregistrer le fichier sur le serveur
-        await fsPromises.mkdir(path.join(process.cwd(), 'uploads', 'private'), {recursive: true});
-        await fsPromises.writeFile(filepath, file.buffer || fs.readFileSync(file.path)); // Utiliser buffer si disponible
-        if( file.path && fs.existsSync(file.path) ){
-            fs.unlinkSync(file.path);
+    const s3Config = await getUserS3Config(user);
+    const extension = getFileExtension(file.name);
+    const newFilename = `${guid}.${extension}`;
+
+    const fileData = {
+        guid: guid,
+        filename: file.name,
+        size: file.size,
+        mimeType: file.type,
+        createdAt: new Date(),
+        user: user.username,
+        mainUser: user._user
+    };
+
+    if (s3Config && s3Config.bucketName && s3Config.accessKeyId && s3Config.secretAccessKey) { // Correction: bucketName au lieu de bucket
+        try {
+            // Correction: Appel manquant à la fonction de téléversement
+            await uploadToS3(s3Config, file.path, newFilename);
+
+            fileData.storage = 's3';
+            fileData.filename = newFilename; // Le nom sur S3
+            logger.info(`Fichier ${newFilename} téléversé sur le bucket S3 ${s3Config.bucketName}.`);
+        } catch (error) {
+            logger.info(`Le téléversement S3 a échoué pour ${file.name}: ${error.message}`, 'error');
+            throw new Error("Le téléversement S3 a échoué.");
+        } finally {
+            // Nettoyer le fichier temporaire uploadé par express-formidable
+            await fsPromises.unlink(file.path).catch(e => logger.info(`Échec de la suppression du fichier temporaire ${file.path}: ${e.message}`, 'error'));
         }
+    } else {
+        // Sauvegarde locale
+        const uploadDir = path.join(process.cwd(), "uploads", "private");
+        if (!fs.existsSync(uploadDir)) {
+            fs.mkdirSync(uploadDir, { recursive: true });
+        }
+        const newPath = path.join(uploadDir, newFilename);
+
+        try {
+            // express-formidable place déjà le fichier dans un répertoire temporaire. Nous n'avons qu'éplacer.
+            await fsPromises.rename(file.path, newPath);
+            fileData.storage = 'local';
+            fileData.filename = newFilename; // Le nom dans le dossier uploads
+            fileData.path = newPath; // Le chemin complet pour les fichiers locaux
+            logger.info(`Fichier ${newFilename} sauvegardé localement dans ${newPath}.`);
+        } catch (error) {
+            logger.info(`Le déplacement du fichier local a échoué pour ${file.name}: ${error.message}`, 'error');
+            // Essayer de nettoyer le fichier temporaire même si le renommage échoue
+            await fsPromises.unlink(file.path).catch(e => logger.info(`Échec de la suppression du fichier temporaire ${file.path}: ${e.message}`, 'error'));
+            throw new Error("Le stockage du fichier local a échoué.");
+        }
+    }
 
-        // Enregistrer les métadonnées du fichier
-        const fileMetadata = {
-            guid,
-            filename: file.originalname || file.name, // Conserver le nom original
-            mimeType: file.type,
-            size: file.size,
-            mainUser: user._user,
-            user: user.username,
-            timestamp: new Date()
-        };
-
-        // Insérer le fichier dans une collection dédiée (par exemple, "privateFiles")
-        const result = await collection.insertOne({...fileMetadata, _model: "privateFile"});
-        if (!result.insertedId) throw new Error("Échec de l'indexation du fichier.");
+    const filesCollection = await getCollection("files");
+    await filesCollection.insertOne(fileData);
 
-        return guid;
+    return guid;
+};
 
-    } catch (error) {
-        // Nettoyage en cas d'erreur
-        if (fs.existsSync(filepath)) {
-            fs.unlinkSync(filepath);
-        }
-        throw new Error(`Erreur lors de l'ajout du fichier: ${error.message}`);
-    }
+/**
+ * Récupère les métadonnées d'un fichier depuis la base de données.
+ * @param {string} guid - Le GUID du fichier.
+ * @returns {Promise<object|null>} L'objet de métadonnées du fichier ou null si non trouvé.
+ */
+export const getFile = async (guid) => {
+    const filesCollection = await getCollection("files");
+    return await filesCollection.findOne({ guid });
 };
 
 export const removeFile = async (guid, user) => {
     if (!guid) return false;
     if (!isGUID(guid)) throw new Error("Le GUID du fichier n'est pas valide.");
 
-    const collection = getCollection("files");
-
-    // Trouver le fichier et vérifier l'autorisation (propriétaire ou admin)
-    const file = await collection.findOne({ guid });
-    if (!file) throw new Error("Fichier non trouvé (" + guid + ")");
-
-    if (user.username !== 'demo' && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_EDIT_DATA", "API_EDIT_DATA_privateFile", `API_EDIT_DATA_privateFile_${guid}`], user) ) {
-        if (file._user !== (user._user || user.username)) {
-            throw new Error("Vous n'êtes pas autorisé à supprimer ce fichier.");
-        }
+    const fileData = await getFile(guid);
+    if (!fileData) {
+        logger.info(`Tentative de suppression d'un fichier inexistant avec le GUID : ${guid}`, 'warn');
+        return;
     }
 
-    try {
-        // Supprimer le fichier de la base de données
-        const deleteResult = await collection.deleteOne({ _model: "privateFile", guid });
-        if (deleteResult.deletedCount !== 1) throw new Error("Échec de la suppression de l'indexation du fichier.");
-
-        // Supprimer le fichier du serveur
-        const filepath = path.join(process.cwd(), 'uploads', 'private', guid)+'.'+getFileExtension(file.filename);
-        if (fs.existsSync(filepath)) {
-            fs.unlinkSync(filepath);
+    if (fileData.storage === 's3') {
+        const s3Config = await getUserS3Config(user);
+        if (s3Config && s3Config.bucketName) { // Correction: bucketName au lieu de bucket
+            try {
+                await deleteFromS3(s3Config, fileData.filename);
+                logger.info(`Fichier ${fileData.filename} supprimé du bucket S3 ${s3Config.bucketName}.`);
+            } catch (error) {
+                logger.info(`La suppression S3 a échoué pour ${fileData.filename}: ${error.message}`, 'error');
+                throw new Error("La suppression S3 a échoué.");
+            }
+        } else {
+            logger.info(`Configuration S3 non trouvée pour l'utilisateur, impossible de supprimer le fichier ${fileData.filename} de S3.`, 'error');
+            throw new Error("Configuration S3 non trouvée, impossible de supprimer le fichier.");
+        }
+    } else if (fileData.storage === 'local') {
+        try {
+            if (fileData.path && fs.existsSync(fileData.path)) {
+                await fsPromises.unlink(fileData.path);
+                logger.info(`Fichier local ${fileData.path} supprimé.`);
+            } else {
+                logger.info(`Fichier local non trouvé au chemin ${fileData.path}, mais suppression de l'enregistrement en BDD.`, 'warn');
+            }
+        } catch (error) {
+            logger.info(`La suppression du fichier local a échoué pour ${fileData.path}: ${error.message}`, 'error');
+            throw new Error("La suppression du fichier local a échoué.");
         }
-
-        return { success: true, message: "Fichier supprimé avec succès." };
-    } catch (error) {
-        throw new Error(`Erreur lors de la suppression du fichier: ${error.message}`);
     }
+
+    const filesCollection = await getCollection("files");
+    await filesCollection.deleteOne({ guid });
 };
 
 
@@ -190,7 +231,7 @@ export async function decryptFile(filePath, password) {
     }
 }
 
-let engine;
 export async function onInit(defaultEngine) {
     engine = defaultEngine;
+    logger = engine.getComponent(Logger);
 }

package/src/modules/test

@@ -0,0 +1,147 @@
+// src/modules/file.js
+import { getCollection } from "./mongodb.js";
+import { uuidv4, getFileExtension } from "../core.js";
+import { getUserS3Config, uploadToS3, deleteFromS3 } from "./bucket.js";
+import { maxFileSize } from "../constants.js";
+import path from "node:path";
+import fs from "node:fs";
+import { promises as fsPromises } from "node:fs";
+import { Logger } from "../gameObject.js";
+
+let logger;
+
+const getLogger = () => {
+    if (!logger) {
+        logger = new Logger();
+    }
+    return logger;
+};
+
+/**
+ * Ajoute un fichier au système. Le téléverse sur S3 si configuré, sinon le sauvegarde localement.
+ * @param {object} file - L'objet fichier provenant de express-formidable.
+ * @param {object} user - L'objet utilisateur.
+ * @returns {Promise<string>} Le GUID du fichier nouvellement ajouté.
+ */
+export const addFile = async (file, user) => {
+    if (!file) {
+        throw new Error("Aucun fichier fourni.");
+    }
+    if (file.size > maxFileSize) {
+        throw new Error(`La taille du fichier dépasse la limite de ${maxFileSize / 1024 / 1024} Mo.`);
+    }
+
+    const guid = uuidv4();
+    const extension = getFileExtension(file.name);
+    const newFilename = `${guid}.${extension}`;
+    const s3Config = await getUserS3Config(user);
+
+    const fileData = {
+        _id: guid,
+        guid: guid,
+        originalFilename: file.name,
+        size: file.size,
+        mimetype: file.type,
+        createdAt: new Date(),
+        user: user.username // Bonne pratique : garder une trace de l'uploader
+    };
+
+    if (s3Config && s3Config.bucketName) { // Correction: bucketName au lieu de bucket
+        try {
+            // Correction: Appel manquant à la fonction de téléversement
+            await uploadToS3(s3Config, file.path, newFilename);
+
+            fileData.storage = 's3';
+            fileData.filename = newFilename; // Le nom sur S3
+            getLogger().log(`Fichier ${newFilename} téléversé sur le bucket S3 ${s3Config.bucketName}.`);
+        } catch (error) {
+            getLogger().log(`Le téléversement S3 a échoué pour ${file.name}: ${error.message}`, 'error');
+            throw new Error("Le téléversement S3 a échoué.");
+        } finally {
+            // Nettoyer le fichier temporaire uploadé par express-formidable
+            await fsPromises.unlink(file.path).catch(e => getLogger().log(`Échec de la suppression du fichier temporaire ${file.path}: ${e.message}`, 'error'));
+        }
+    } else {
+        // Sauvegarde locale
+        const uploadDir = path.join(process.cwd(), "uploads");
+        if (!fs.existsSync(uploadDir)) {
+            fs.mkdirSync(uploadDir, { recursive: true });
+        }
+        const newPath = path.join(uploadDir, newFilename);
+
+        try {
+            // express-formidable place déjà le fichier dans un répertoire temporaire. Nous n'avons qu'éplacer.
+            await fsPromises.rename(file.path, newPath);
+            fileData.storage = 'local';
+            fileData.filename = newFilename; // Le nom dans le dossier uploads
+            fileData.path = newPath; // Le chemin complet pour les fichiers locaux
+            getLogger().log(`Fichier ${newFilename} sauvegardé localement dans ${newPath}.`);
+        } catch (error) {
+            getLogger().log(`Le déplacement du fichier local a échoué pour ${file.name}: ${error.message}`, 'error');
+            // Essayer de nettoyer le fichier temporaire même si le renommage échoue
+            await fsPromises.unlink(file.path).catch(e => getLogger().log(`Échec de la suppression du fichier temporaire ${file.path}: ${e.message}`, 'error'));
+            throw new Error("Le stockage du fichier local a échoué.");
+        }
+    }
+
+    const filesCollection = await getCollection("files");
+    await filesCollection.insertOne(fileData);
+
+    return guid;
+};
+
+/**
+ * Récupère les métadonnées d'un fichier depuis la base de données.
+ * @param {string} guid - Le GUID du fichier.
+ * @returns {Promise<object|null>} L'objet de métadonnées du fichier ou null si non trouvé.
+ */
+export const getFile = async (guid) => {
+    const filesCollection = await getCollection("files");
+    return await filesCollection.findOne({ guid });
+};
+
+/**
+ * Supprime un fichier du système (S3 ou local) et son enregistrement en base de données.
+ * @param {string} guid - Le GUID du fichier à supprimer.
+ * @param {object} user - L'objet utilisateur.
+ * @returns {Promise<void>}
+ */
+export const deleteFile = async (guid, user) => {
+    const fileData = await getFile(guid);
+    if (!fileData) {
+        getLogger().log(`Tentative de suppression d'un fichier inexistant avec le GUID : ${guid}`, 'warn');
+        return;
+    }
+
+    if (fileData.storage === 's3') {
+        const s3Config = await getUserS3Config(user);
+        if (s3Config && s3Config.bucketName) { // Correction: bucketName au lieu de bucket
+            try {
+                await deleteFromS3(s3Config, fileData.filename);
+                getLogger().log(`Fichier ${fileData.filename} supprimé du bucket S3 ${s3Config.bucketName}.`);
+            } catch (error) {
+                getLogger().log(`La suppression S3 a échoué pour ${fileData.filename}: ${error.message}`, 'error');
+                throw new Error("La suppression S3 a échoué.");
+            }
+        } else {
+             getLogger().log(`Configuration S3 non trouvée pour l'utilisateur, impossible de supprimer le fichier ${fileData.filename} de S3.`, 'error');
+             throw new Error("Configuration S3 non trouvée, impossible de supprimer le fichier.");
+        }
+    } else if (fileData.storage === 'local') {
+        try {
+            if (fileData.path && fs.existsSync(fileData.path)) {
+                await fsPromises.unlink(fileData.path);
+                getLogger().log(`Fichier local ${fileData.path} supprimé.`);
+            } else {
+                getLogger().log(`Fichier local non trouvé au chemin ${fileData.path}, mais suppression de l'enregistrement en BDD.`, 'warn');
+            }
+        } catch (error) {
+            getLogger().log(`La suppression du fichier local a échoué pour ${fileData.path}: ${error.message}`, 'error');
+            throw new Error("La suppression du fichier local a échoué.");
+        }
+    }
+
+    const filesCollection = await getCollection("files");
+    await filesCollection.deleteOne({ guid });
+    getLogger().log(`Enregistrement du fichier ${guid} supprimé de la base de données.`);
+};

package/src/modules/user.js

@@ -88,73 +88,128 @@ export async function onInit(defaultEngine) {
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
 }
+/**
+ * Calcule et retourne l'ensemble des permissions actives pour un utilisateur.
+ * Cette fonction interne est la pierre angulaire de la nouvelle logique de permission.
+ * 1. Elle récupère toutes les permissions de base issues des rôles de l'utilisateur.
+ * 2. Elle applique ensuite les "exceptions" (ajouts ou retraits de permissions) qui sont valides (non expirées).
+ * @param {object} user - L'objet utilisateur pour lequel calculer les permissions.
+ * @returns {Promise<Set<string>>} Un Set contenant les noms de toutes les permissions actives.
+ * @private
+ */
+export async function getUserActivePermissions(user) {
+    const datasCollection = await getCollectionForUser(user);
+    const now = new Date();
+    const activePermissions = new Set();
 
-export async function hasPermission(permissionNames, user) {
-    if( !isLocalUser(user)){
-        return user.roles?.some(f => permissionNames.includes(f));
-    }
-    try {
-        // Si on a une string on le transforme en tableau.
-        const permissionNamesArray = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
-        const collection = await getCollectionForUser(user);
+    // --- ÉTAPE 1: Récupérer les permissions de base des rôles ---
+    if (user.roles && user.roles.length > 0) {
+        const roleIds = user.roles.map(id => new ObjectId(id));
 
-        const job = [
+        const rolePermissions = await datasCollection.aggregate([
+            { $match: { _id: { $in: roleIds }, _model: "role" } },
+            { $unwind: "$permissions" },
+            { $addFields: { "permissionId": { "$toObjectId": "$permissions" } } },
             {
                 $lookup: {
-                    from: 'datas',
-                    let: { rolesIds: (user.roles ||[]).map(m => new ObjectId(m)) },
-                    pipeline: [
-                        {
-                            $match: {
-                                $expr: {
-                                    $and: [
-                                        { $in: ['$_id', '$$rolesIds'] }
-                                    ]
-                                }
-                            }
-                        },
-                        {
-                            $lookup: {
-                                from: 'datas',
-                                let: { rolePermissions: {
-                                    "$map": {
-                                        "input": "$permissions",
-                                        "in": { "$toObjectId": "$$this" }
-                                    }
-                                } },
-                                pipeline: [
-                                    {
-                                        $match: {
-                                            $expr: {
-                                                $and: [
-                                                    { $in: ['$_id', '$$rolePermissions'] }
-                                                ]
-                                            }
-                                        }
-                                    },
-                                    { $limit: 1 }
-                                ],
-                                as: 'permissions'
-                            }
-                        },
-                        { $unwind: { path: '$permissions', preserveNullAndEmptyArrays: true } }
-                    ],
-                    as: 'roles'
+                    from: datasCollection.collectionName, // Utiliser la même collection
+                    localField: "permissionId",
+                    foreignField: "_id",
+                    as: "permissionDoc"
                 }
             },
-            { $unwind: { path: '$roles', preserveNullAndEmptyArrays: true } },
-            { $match: { 'roles.permissions.name': { $in: permissionNamesArray } } }, // Match if permissions.name in array
-            { $limit: 1 },
-            { $project: { _id: 0, hasPermission: { $cond: [{ $in: ['$roles.permissions.name', permissionNamesArray] }, true, false] } } } //check the value
-        ];
-        const result = await collection.aggregate(job).toArray();
-        return result.length === 1 && result[0].hasPermission;
+            { $unwind: "$permissionDoc" },
+            { $group: { _id: "$permissionDoc.name" } }
+        ]).toArray();
+
+        rolePermissions.forEach(p => p._id && activePermissions.add(p._id));
+    }
+
+    // --- ÉTAPE 2: Appliquer les exceptions de permission ---
+    const exceptions = await datasCollection.aggregate([
+        {
+            $match: {
+                _model: "userPermission",
+                user: user._id, // Pas besoin de convertir en ObjectId si c'est déjà une string
+                $or: [
+                    { expiresAt: { $exists: false } },
+                    { expiresAt: { $gt: now } }
+                ]
+            }
+        },
+        {
+            $lookup: {
+                from: datasCollection.collectionName,
+                let: { permissionId: "$permission" },
+                pipeline: [
+                    {
+                        $match: {
+                            $expr: {
+                                $eq: [
+                                    "$_id",
+                                    { $toObjectId: "$$permissionId" } // Conversion ici
+                                ]
+                            }
+                        }
+                    },
+                    { $project: { name: 1 } }
+                ],
+                as: 'permissionDoc'
+            }
+        },
+        { $unwind: '$permissionDoc' }
+    ]).toArray();
+
+    // Appliquer les exceptions
+    for (const exception of exceptions) {
+        const permissionName = exception.permissionDoc?.name;
+        if (!permissionName) continue;
+
+        if (exception.isGranted) {
+            activePermissions.add(permissionName);
+        } else {
+            activePermissions.delete(permissionName);
+        }
+    }
+
+    return activePermissions;
+}
+
+/**
+ * Vérifie si un utilisateur possède au moins une des permissions spécifiées.
+ * Cette fonction utilise la nouvelle logique basée sur les rôles et les exceptions de permission.
+ * @param {string|string[]} permissionNames - Le nom de la permission ou un tableau de noms.
+ * @param {object} user - L'objet utilisateur authentifié.
+ * @returns {Promise<boolean>} - True si l'utilisateur a la permission, sinon false.
+ */
+export async function hasPermission(permissionNames, user) {
+    // Garde la compatibilité pour les utilisateurs non-locaux (ex: système)
+    if (!isLocalUser(user)) {
+        const userRoles = new Set(user.roles || []);
+        const requiredPermissions = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
+        return requiredPermissions.some(p => userRoles.has(p));
+    }
+
+    try {
+        const requiredPermissions = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
+        // Si aucune permission n'est requise, on autorise
+        if (requiredPermissions.length === 0) {
+            return true;
+        }
+
+        // 1. Obtenir l'ensemble final et à jour des permissions de l'utilisateur
+        const activePermissions = await getUserActivePermissions(user);
+
+        // 2. Vérifier si au moins une des permissions requises est dans l'ensemble des permissions actives
+        return requiredPermissions.some(pName => activePermissions.has(pName));
+
     } catch (e) {
-        logger.error(e);
+        logger.error("Erreur lors de la vérification des permissions :", e);
         return false;
     }
 }
 
+
 /**
  * Calcule l'utilisation totale de l'espace de stockage pour un utilisateur en octets.
  * Cela inclut la taille des documents dans sa collection de données et la taille de ses fichiers uploadés.

package/test/data.backup.integration.test.js

@@ -70,7 +70,7 @@ beforeAll(async () => {
     fs.readdirSync(backupDir).forEach(file => {
         fs.unlinkSync(path.join(backupDir, file));
     });
-    vi.stubEnv('S3_CONFIG_ENCRYPTION_KEY', '00000000000000000000000000000000');
+    vi.stubEnv('ENCRYPTION_KEY', '00000000000000000000000000000000');
     vi.stubEnv('OPENAI_API_KEY', '00000000000000000000000000000000');
     // You might need to create a model first if your dumpUserData requires it
     await createModel(testModelDefinition);