data-primals-engine 1.2.2 → 1.2.4

package/test/model.integration.test.js

@@ -1,34 +1,33 @@
 // __tests__/data.integration.test.js
 import { ObjectId } from 'mongodb';
-import {expect, describe, it, beforeEach, afterEach, beforeAll, afterAll, vi} from 'vitest';
+import {expect, describe, it, beforeAll} from 'vitest';
 import { Config } from '../src/config.js';
 
 import {
-    modelsCollection as getAppModelsCollection,
-    datasCollection // Accès direct pour vérifications
-} from 'data-primals-engine/modules/mongodb';
-import {generateUniqueName, getUniquePort, initEngine} from "../src/setenv.js";
-import {editModel} from "../src/modules/data.js";
+    getCollection // Accès direct pour vérifications
+} from '../src/modules/mongodb.js';
+import {generateUniqueName, initEngine} from "../src/setenv.js";
+import {editModel} from "../src/index.js";
 import {getCollectionForUser} from "../src/modules/mongodb.js";
 
 let testModelsColInstance;
-let testDatasColInstance;
-
 let testModelId;
-
 // Cette fonction va remplacer la logique de votre beforeEach pour la création de contexte
 async function setupTestContext() {
 
     const currentTestModelName = generateUniqueName('relatedModel');
     const currentRelatedModelName = generateUniqueName('comprehensiveModel');
 
+
     // Créer un utilisateur unique pour ce test
     const currentTestUser = {
-        username: generateUniqueName('testuserDataIntegration'),
+        username: generateUniqueName('testuserModelIntegration'),
         userPlan: 'free',
         email: generateUniqueName('test') + '@example.com'
     };
 
+    testModelsColInstance = getCollection("models");
+    const testDatasColInstance = await getCollectionForUser(currentTestUser);
 
     const relatedModelDefinition = {
         name: currentRelatedModelName,
@@ -105,43 +104,42 @@ async function setupTestContext() {
     await testDatasColInstance.deleteMany({ _user: currentTestUser.username });
     await testDatasColInstance.deleteMany({ _model: { $in: [comprehensiveTestModelDefinition.name, 'renamedTestModel'] } });
     // Retourner toutes les variables nécessaires pour un test
+
     return {
         currentTestUser,
+        coll:testDatasColInstance,
         comprehensiveTestModelDefinition,
         relatedModelDefinition
     };
 }
 
+
 describe('CRUD on model definitions and integrity tests', () => {
 
     beforeAll(async () =>{
         Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
         await initEngine();
-
-        // Initialize collection instances after the engine is ready
-        testModelsColInstance = getAppModelsCollection;
-        testDatasColInstance = datasCollection;
     })
+
     describe('editModel unit tests', () => {
 
         it('should create and drop index when field.index is toggled (premium user)', async () => {
             // --- SETUP ---
-            const { currentTestUser, comprehensiveTestModelDefinition } = await setupTestContext();
-            const dataCollection = await getCollectionForUser(currentTestUser);
+            const { coll, currentTestUser, comprehensiveTestModelDefinition } = await setupTestContext();
             const fieldToIndex = 'stringUnique'; // Utiliser un champ qui existe vraiment dans le modèle
 
             // --- FIX: Ensure the collection exists before any operation ---
             // By inserting and deleting a dummy document, we force MongoDB to create the
             // collection and its default indexes. This prevents the "ns does not exist"
             // error in asynchronous listeners (like workflow triggers).
-            const dummyDoc = await dataCollection.insertOne({ _model: 'dummy', _user: currentTestUser.username });
-            await dataCollection.deleteOne({ _id: dummyDoc.insertedId });
+            const dummyDoc = await coll.insertOne({ _model: 'dummy', _user: currentTestUser.username });
+            await coll.deleteOne({ _id: dummyDoc.insertedId });
 
 
             // --- VERIFICATION INITIALE ---
             // S'assurer qu'aucun index n'existe au départ.
             // Cet appel ne plantera plus car la collection est maintenant créée.
-            const initialIndexes = await dataCollection.indexes();
+            const initialIndexes = await coll.indexes();
             expect(initialIndexes.some(i => i.key[fieldToIndex] === 1)).toBe(false);
 
             // --- ACTION 1 : AJOUTER UN INDEX ---
@@ -155,7 +153,7 @@ describe('CRUD on model definitions and integrity tests', () => {
 
             // --- VERIFICATION 1 ---
             // Maintenant, la collection et l'index doivent exister.
-            const indexesAfterCreation = await dataCollection.indexes();
+            const indexesAfterCreation = await coll.indexes();
             const newIndex = indexesAfterCreation.find(i => i.key[fieldToIndex] === 1);
 
             expect(newIndex).toBeDefined();
@@ -175,8 +173,9 @@ describe('CRUD on model definitions and integrity tests', () => {
             await editModel(currentTestUser, testModelId, modelWithoutIndex);
 
             // --- VERIFICATION 2 ---
-            const indexesAfterDeletion = await dataCollection.indexes();
+            const indexesAfterDeletion = await coll.indexes();
             expect(indexesAfterDeletion.some(i => i.key[fieldToIndex] === 1)).toBe(false);
+
         }, 20000);
 
         it('should not save extra, non-defined fields in the model definition', async () => {

package/test/user.test.js

@@ -1,11 +1,11 @@
 import { expect, describe, it, beforeEach, beforeAll, afterAll } from 'vitest';
 import { hasPermission, getUserActivePermissions } from '../src/modules/user.js';
-import {initEngine} from "data-primals-engine/setenv";
+import {initEngine} from "../src/setenv";
 import {generateUniqueName} from "../src/setenv.js";
 import {
     getCollectionForUser as getAppUserCollection,
     modelsCollection as getAppModelsCollection
-} from "data-primals-engine/modules/mongodb";
+} from "../src/modules/mongodb.js";
 import {Config} from "../src/index.js";
 let permRead, permWrite, permDelete, permManage;
 let roleEditor;
@@ -17,7 +17,7 @@ async function setupTestContext() {
 
 
     // Créer un utilisateur unique pour ce test
-    const username = generateUniqueName('testuserDataIntegration');
+    const username = generateUniqueName('testuserUserIntegration');
     currentTestUser = {
         username,
         userPlan: 'free',
@@ -58,6 +58,8 @@ async function setupTestContext() {
     ]);
     testUser = {...currentTestUser, _id: users.insertedIds[0].toString(), roles: [roleEditor.toString()] };
     adminUser = {...currentTestUser,  _id: users.insertedIds[1].toString(), roles: [roleEditor.toString()] };
+
+    return testDatasColInstance;
 };
 let engine;
 describe('User Permission Logic', () => {
@@ -72,26 +74,24 @@ describe('User Permission Logic', () => {
     // --- Tests pour la fonction principale de calcul ---
     describe('getUserActivePermissions()', () => {
 
-
-        beforeEach(async () =>{
-            await setupTestContext();
-        })
         it('should return base permissions from the user\'s role', async () => {
+            const coll = await setupTestContext();
             const permissions = await getUserActivePermissions(testUser);
             expect(permissions).to.be.an.instanceOf(Set);
             expect(permissions.size).to.equal(2);
             expect(permissions.has('post:read')).to.be.true;
             expect(permissions.has('post:write')).to.be.true;
             expect(permissions.has('post:delete')).to.be.false;
+            await coll.drop();
         });
 
         it('should grant a temporary permission via an exception', async () => {
-
+            const coll = await setupTestContext();
             // Ajoute une exception qui donne la permission de supprimer, expirant demain
             const futureDate = new Date();
             futureDate.setDate(futureDate.getDate() + 1);
 
-            await testDatasColInstance.insertOne({
+            await coll.insertOne({
                 _model: 'userPermission',
                 user: testUser._id,
                 permission: permDelete,
@@ -104,15 +104,18 @@ describe('User Permission Logic', () => {
             expect(permissions.has('post:delete')).to.be.true;
 
             // Nettoyage de l'exception pour ne pas affecter les autres tests
-            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.deleteOne({ _model: 'userPermission', user: testUser._id });
+
+            await coll.drop();
         });
 
         it('should NOT grant an expired temporary permission', async () => {
+            const coll = await setupTestContext();
             // Ajoute une exception qui a expiré hier
             const pastDate = new Date();
             pastDate.setDate(pastDate.getDate() - 1);
 
-            await testDatasColInstance.insertOne({
+            await coll.insertOne({
                 _model: 'userPermission',
                 user: testUser._id,
                 permission: permDelete,
@@ -124,15 +127,17 @@ describe('User Permission Logic', () => {
             expect(permissions.size).to.equal(2); // Revient la normale
             expect(permissions.has('post:delete')).to.be.false;
 
-            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.drop();
         });
 
         it('should revoke a base permission via an exception', async () => {
+            const coll = await setupTestContext();
             // L'utilisateur est "Editor", mais on lui retire le droit d'écriture temporairement
             const futureDate = new Date();
             futureDate.setDate(futureDate.getDate() + 1);
 
-            await testDatasColInstance.insertOne({
+            await coll.insertOne({
                 _model: 'userPermission',
                 user: testUser._id,
                 permission: permWrite,
@@ -145,15 +150,17 @@ describe('User Permission Logic', () => {
             expect(permissions.has('post:read')).to.be.true;
             expect(permissions.has('post:write')).to.be.false; // La permission a été retirée
 
-            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.drop();
         });
 
         it('should restore a revoked permission if the revocation has expired', async () => {
+            const coll = await setupTestContext();
             // La révocation a expiré, l'utilisateur devrait retrouver son droit d'écriture
             const pastDate = new Date();
             pastDate.setDate(pastDate.getDate() - 1);
 
-            await testDatasColInstance.insertOne({
+            await coll.insertOne({
                 _model: 'userPermission',
                 user: testUser._id,
                 permission: permWrite,
@@ -165,39 +172,39 @@ describe('User Permission Logic', () => {
             expect(permissions.size).to.equal(2);
             expect(permissions.has('post:write')).to.be.true; // La permission est de retour
 
-            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.deleteOne({ _model: 'userPermission', user: testUser._id });
+            await coll.drop();
         });
     });
 
     // --- Tests pour la fonction publique `hasPermission` ---
     describe('hasPermission()', () => {
-        beforeEach(async () => {
-            await setupTestContext();
-        });
         it('should return true for a permission the user has', async () => {
-
-
-            console.log(await testDatasColInstance.find({ _model: 'permission' }).toArray());
-            console.log(await testDatasColInstance.find({ _model: 'role' }).toArray());
-            console.log(await testDatasColInstance.find({ _model: 'user' }).toArray());
-            console.log(await testDatasColInstance.find({ _model: 'userPermission' }).toArray());
+            const coll = await setupTestContext();
             const result = await hasPermission('post:read', testUser);
             expect(result).to.be.true;
+            await coll.drop();
         });
 
         it('should return false for a permission the user does not have', async () => {
+            const coll = await setupTestContext();
             const result = await hasPermission('user:manage', testUser);
             expect(result).to.be.false;
+            await coll.drop();
         });
 
         it('should return true if user has at least one of the required permissions', async () => {
+            const coll = await setupTestContext();
             const result = await hasPermission(['user:manage', 'post:write'], testUser);
             expect(result).to.be.true;
+            await coll.drop();
         });
 
         it('should return false if user has none of the required permissions', async () => {
+            const coll = await setupTestContext();
             const result = await hasPermission(['user:manage', 'post:delete'], testUser);
             expect(result).to.be.false;
+            await coll.drop();
         });
     });
 });

package/test/vm.test.js

@@ -0,0 +1,51 @@
+import {expect, describe, it, beforeEach, afterEach, beforeAll, afterAll, vi, vitest} from 'vitest';
+import ivm from "isolated-vm";
+import {sleep} from "../src/core";
+
+vi.stubEnv('ENCRYPTION_KEY', '12345678901234567890123456789012');
+
+async function executeSafeJavascript() {
+    const isolate = new ivm.Isolate()
+
+    async function myAsyncFunction(str) {
+        await sleep(1000);
+        console.log("hello"+str)
+    }
+
+    const context = await isolate.createContext();
+    const jail = context.global;
+
+    await jail.set('myAsync', new ivm.Reference(myAsyncFunction));
+
+    const fn = await context.eval(`
+        const normalizeArgs = args => args.map(arg => {
+            if (typeof arg === 'object' && arg !== null) {
+                return JSON.stringify(arg); // Convert objects to strings
+            }
+            return arg;
+        });
+        const t = (...args) => {
+            myAsync.applySyncPromise(null, normalizeArgs(args));
+        }
+        (async function untrusted() { 
+            let str = await t("ok", {"ok":true});
+            return str;
+        })
+    `, { reference: true })
+    const value = await fn.apply(undefined, [], { result: { promise: true } })
+}
+
+
+beforeAll(async () => {
+});
+describe('VM system ingration', () => {
+
+    it('should successfully add a file with local storage', async () => {
+        console.log(await executeSafeJavascript({
+            script: 'const t = await addSync();'
+        }, {}, { username:'test'}));
+
+
+        expect(true).toBe(true);
+    });
+});

package/test/workflow.integration.test.js

@@ -1,24 +1,21 @@
-// __tests__/workflow.integration.test.js
 import { expect, describe, it, beforeEach,afterEach, beforeAll, afterAll, vi } from 'vitest';
-import { Config } from "data-primals-engine/config";
-
-import {insertData, editData, deleteData, patchData} from 'data-primals-engine/modules/data';
-import { modelsCollection as getAppModelsCollection, getCollectionForUser } from 'data-primals-engine/modules/mongodb';
-import * as workflowModule from 'data-primals-engine/modules/workflow';
-import {getUniquePort, initEngine} from "../src/setenv.js";
-import process from "process";
+import { Config } from "../src/config";
 
+import {insertData, editData, deleteData, patchData} from '../src/index.js';
+import { modelsCollection as getAppModelsCollection, getCollectionForUser } from '../src/modules/mongodb.js';
+import * as workflowModule from '../src/modules/workflow.js';
+import {initEngine} from "../src/setenv.js";
 
 beforeAll(async () =>{
     Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
     await initEngine();
 })
-vi.mock('data-primals-engine/modules/workflow', { spy: true })
+vi.mock('../src/modules/workflow.js', { spy: true })
 // --- Données Mock pour les tests ---
 const mockUser = {
     username: 'testuserWorkflow',
     _user: 'testuserWorkflow',
-    userPlan: 'free',
+    userPlan: 'premium',
     email: 'testWorkflow@example.com'
 };
 
@@ -138,8 +135,6 @@ const processWorkflowRunSpy = vi.spyOn(workflowModule, 'processWorkflowRun');
 beforeEach(async () => {
     testModelsColInstance = getAppModelsCollection;
     testDatasColInstance = await getCollectionForUser(mockUser);
-    // Nettoyer les données avant chaque test
-    await testDatasColInstance.deleteMany({_user: "testuserWorkflow"});
 
     // Réinitialiser l'espion
     processWorkflowRunSpy.mockClear();
@@ -152,9 +147,19 @@ beforeEach(async () => {
             ...workflowMetaModels.map(m => ({...m})) // Copie pour éviter les mutations
         ]);
     }
-    console.log({mods})
-});
+    // tell vitest we use mocked time
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+})
 
+afterEach(() => {
+    vi.runOnlyPendingTimers();
+    // restoring date after each test run
+    vi.useRealTimers()
+})
+afterAll(async () => {
+    const coll = await getCollectionForUser(mockUser);
+    await coll.drop();
+})
 describe('Intégration des Workflows - triggerWorkflows', () => {
 
     let testWorkflow;
@@ -162,6 +167,9 @@ describe('Intégration des Workflows - triggerWorkflows', () => {
 
     // Avant chaque test de ce bloc, on crée un workflow et une étape de base
     const initTest = async () => {
+        // Nettoyer les données avant chaque test
+        await testDatasColInstance.deleteMany({_user: "testuserWorkflow"});
+
         const workflowInsertResult = await insertData('workflow', { name: 'Test Workflow' }, {}, mockUser, false);
         testWorkflow = { _id: workflowInsertResult.insertedIds[0] };
 

package/test/workflow.robustness.test.js

@@ -1,14 +1,14 @@
 import { ObjectId } from 'mongodb';
-import { expect, describe, it, beforeEach, beforeAll, vi } from 'vitest';
-import { Config } from "data-primals-engine/config";
-// --- Importations des modules de l'application ---
-import { insertData, editData } from 'data-primals-engine/modules/data';
-import { modelsCollection as getAppModelsCollection, getCollectionForUser, getCollection } from 'data-primals-engine/modules/mongodb';
-import * as workflowModule from 'data-primals-engine/modules/workflow';
+import {expect, describe, it, beforeEach, beforeAll, vi, afterAll, afterEach} from 'vitest';
+import { Config } from "../src/config";
+
+import { insertData, editData } from '../src/index.js';
+import { modelsCollection as getAppModelsCollection, getCollectionForUser, getCollection } from '../src/modules/mongodb.js';
+import * as workflowModule from '../src/modules/workflow.js';
 import {initEngine} from "../src/setenv.js";
 import {maxExecutionsByStep} from "../src/constants.js";
 
-vi.mock('data-primals-engine/modules/workflow', { spy: true })
+vi.mock('../src/modules/workflow.js', { spy: true })
 
 const mockUser = {
     username: 'robustnessUser',
@@ -41,12 +41,22 @@ beforeEach(async () => {
     await testDatasColInstance.deleteMany({ _user: mockUser.username });
     await getCollection('job_locks').deleteMany({}); // Nettoyer les verrous
     const mods = await testModelsColInstance.find({ $and: [{_user: mockUser.username}, {$or: [{name: targetDataModel.name}, ...workflowMetaModels.map(m =>({name: m.name}))] }]}).toArray();
-    console.log({mods})
     if( mods.length === 0){
         await testModelsColInstance.insertMany([targetDataModel, ...workflowMetaModels]);
     }
-});
+    // tell vitest we use mocked time
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+})
 
+afterEach(() => {
+    vi.runOnlyPendingTimers();
+    // restoring date after each test run
+    vi.useRealTimers()
+})
+afterAll(async () => {
+    const coll = await getCollectionForUser(mockUser);
+    await coll.drop();
+})
 // ====================================================================================
 // =================== DÉBUT DES TESTS DE ROBUSTESSE ==================================
 // ====================================================================================

package/src/modules/test

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