data-primals-engine 1.2.1 → 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/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);

package/test/events.test.js

@@ -0,0 +1,202 @@
+// events.test.js
+import { Event } from '../src/events.js';
+import {vitest} from "vitest";
+import {expect, describe, it, beforeEach, beforeAll, afterAll} from 'vitest';
+
+describe('Event System', () => {
+    beforeEach(() => {
+        // Clear all events before each test to ensure a clean state
+        for (const system in Event) {
+            if (Event.hasOwnProperty(system) && typeof Event[system] === 'object') {
+                for (const eventName in Event[system]) {
+                    if (Event[system].hasOwnProperty(eventName)) {
+                        delete Event[system][eventName];
+                    }
+                }
+            }
+        }
+    });
+
+    it('should allow listening for and triggering an event', () => {
+        const mockCallback = vitest.fn();
+        const eventName = 'testEvent';
+
+        Event.Listen(eventName, mockCallback);
+        Event.Trigger(eventName);
+
+        expect(mockCallback).toHaveBeenCalledTimes(1);
+    });
+    it('should pass arguments to the event callback', () => {
+        const mockCallback = vitest.fn();
+        const eventName = 'testEventWithArgs';
+        const arg1 = 'hello';
+        const arg2 = 123;
+
+        Event.Listen(eventName, mockCallback, "priority", "medium");
+        Event.Trigger(eventName, "priority", "medium", arg1, arg2);
+
+        expect(mockCallback).toHaveBeenCalledTimes(1);
+        expect(mockCallback).toHaveBeenCalledWith(arg1, arg2);
+    });
+
+    it('should allow removing a specific callback', () => {
+        const mockCallback1 = vitest.fn();
+        const mockCallback2 = vitest.fn();
+        const eventName = 'testEventRemoveCallback';
+
+        Event.Listen(eventName, mockCallback1);
+        Event.Listen(eventName, mockCallback2);
+        Event.RemoveCallback(eventName, mockCallback1);
+        Event.Trigger(eventName);
+
+        expect(mockCallback1).not.toHaveBeenCalled();
+        expect(mockCallback2).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not trigger a callback if the event is not listened to', () => {
+        const mockCallback = vitest.fn();
+        const eventName = 'nonExistentEvent';
+
+        Event.Trigger(eventName);
+
+        expect(mockCallback).not.toHaveBeenCalled();
+    });
+
+    it('should handle different systems and layers', () => {
+        const mockCallbackPriority = vitest.fn();
+        const mockCallbackLog = vitest.fn();
+        const eventName = 'testEventMultiSystem';
+
+        Event.Listen(eventName, mockCallbackPriority, 'priority', 'high');
+        Event.Listen(eventName, mockCallbackLog, 'log', 'info');
+
+        Event.Trigger(eventName, 'priority', 'high');
+        expect(mockCallbackPriority).toHaveBeenCalledTimes(1);
+        expect(mockCallbackLog).not.toHaveBeenCalled();
+
+        vitest.clearAllMocks(); // Reset mock counts
+
+        Event.Trigger(eventName, 'log', 'info');
+        expect(mockCallbackPriority).not.toHaveBeenCalled();
+        expect(mockCallbackLog).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw an error if an invalid system or layer is used with Listen', () => {
+        expect(() => {
+            Event.Listen('invalidEvent', () => {}, 'invalidSystem', 'invalidLayer');
+        }).toThrowError(/System 'invalidSystem' does not exist./);
+
+        expect(() => {
+            Event.Listen('invalidEvent', () => {}, 'priority', 'invalidLayer');
+        }).toThrowError(/Layer 'invalidLayer' does not exist/);
+    });
+
+    describe('Event.Trigger result merging', () => {
+        it('should merge objects from multiple callbacks using spread operator', () => {
+            const eventName = 'mergeObjectEvent';
+            const callback1 = vitest.fn().mockReturnValue({ a: 1, b: 2 });
+            const callback2 = vitest.fn().mockReturnValue({ b: 3, c: 4 }); // b will be overwritten
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+
+            const result = Event.Trigger(eventName);
+
+            expect(result).toEqual({ a: 1, b: 3, c: 4 });
+        });
+
+        it('should concatenate arrays from multiple callbacks', () => {
+            const eventName = 'mergeArrayEvent';
+            const callback1 = vitest.fn().mockReturnValue([1, 2]);
+            const callback2 = vitest.fn().mockReturnValue([3, 4]);
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+
+            const result = Event.Trigger(eventName);
+
+            expect(result).toEqual([1, 2, 3, 4]);
+        });
+
+        it('should concatenate strings from multiple callbacks', () => {
+            const eventName = 'mergeStringEvent';
+            const callback1 = vitest.fn().mockReturnValue('Hello ');
+            const callback2 = vitest.fn().mockReturnValue('World');
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+
+            const result = Event.Trigger(eventName);
+
+            expect(result).toBe('Hello World');
+        });
+
+        it('should add numbers from multiple callbacks', () => {
+            const eventName = 'mergeNumberEvent';
+            const callback1 = vitest.fn().mockReturnValue(10);
+            const callback2 = vitest.fn().mockReturnValue(20);
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+
+            const result = Event.Trigger(eventName);
+
+            expect(result).toBe(30);
+        });
+
+        it('should perform a logical AND on booleans from multiple callbacks', () => {
+            const eventName = 'mergeBooleanEvent';
+
+            // Case 1: true && true -> true
+            const cb_true1 = vitest.fn().mockReturnValue(true);
+            const cb_true2 = vitest.fn().mockReturnValue(true);
+            Event.Listen(eventName, cb_true1);
+            Event.Listen(eventName, cb_true2);
+            expect(Event.Trigger(eventName)).toBe(true);
+            Event.RemoveAllCallbacks(eventName); // Clean up for next case
+
+            // Case 2: true && false -> false
+            const cb_false1 = vitest.fn().mockReturnValue(false);
+            Event.Listen(eventName, cb_true1);
+            Event.Listen(eventName, cb_false1);
+            expect(Event.Trigger(eventName)).toBe(false);
+            Event.RemoveAllCallbacks(eventName);
+
+            // Case 3: false && true -> false
+            Event.Listen(eventName, cb_false1);
+            Event.Listen(eventName, cb_true1);
+            expect(Event.Trigger(eventName)).toBe(false);
+        });
+
+        it('should handle mixed-type return values', () => {
+            const eventName = 'mergeMixedEvent';
+            const callback1 = vitest.fn().mockReturnValue(100); // number
+            const callback2 = vitest.fn().mockReturnValue({ a: 1 }); // object
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+
+            const result = Event.Trigger(eventName);
+
+            // The logic initializes `ret` with the first value (100).
+            // When the second callback returns an object, it re-initializes `ret` to {}
+            // and merges the object. The final result is the object.
+            expect(result).toEqual({ a: 1 });
+        });
+
+        it('should ignore null and undefined return values while merging', () => {
+            const eventName = 'ignoreNullsEvent';
+            const callback1 = vitest.fn().mockReturnValue(null);
+            const callback2 = vitest.fn().mockReturnValue({ data: 'important' });
+            const callback3 = vitest.fn().mockReturnValue(undefined);
+
+            Event.Listen(eventName, callback1);
+            Event.Listen(eventName, callback2);
+            Event.Listen(eventName, callback3);
+
+            const result = Event.Trigger(eventName);
+
+            expect(result).toEqual({ data: 'important' });
+        });
+    });
+});