data-primals-engine 1.2.0 → 1.2.2

package/client/src/RestoreConfirmationModal.jsx

@@ -15,80 +15,6 @@ const RestoreConfirmationModal = ({ isOpen, onClose, onConfirm, showS3Config = f
     const { me, fetchMe } = useAuthContext(); // fetchMe pour recharger les données utilisateur après sauvegarde
     const { addNotification } = useNotificationContext();
 
-    // États pour les champs de configuration S3
-    const [s3Config, setS3Config] = useState({
-        bucketName: '',
-        accessKeyId: '',
-        secretAccessKey: '', // Ne sera pas affiché directement mais envoyé
-        region: ''
-    });
-    const [isSavingS3Config, setIsSavingS3Config] = useState(false);
-    const [showConfig, setConfigVisible] = useState(false);
-
-    // Charger la configuration S3 existante de l'utilisateur au montage si me.s3Config existe
-    useEffect(() => {
-        if (me?.s3Config && showS3Config) {
-            setS3Config({
-                bucketName: me.s3Config.bucketName || '',
-                accessKeyId: me.s3Config.accessKeyId || '',
-                secretAccessKey: '', // Ne pas pré-remplir la clé secrète pour la sécurité
-                region: me.s3Config.region || '',
-                pathPrefix: me.s3Config.pathPrefix || ''
-            });
-        } else if (showS3Config) {
-            // Réinitialiser si pas de config ou si on quitte la section S3
-            setS3Config({ bucketName: '', accessKeyId: '', secretAccessKey: '', region: '', pathPrefix: '' });
-        }
-    }, [me, showS3Config, isOpen]); // Ajouter isOpen pour recharger si la modale est rouverte
-
-
-    const handleS3ConfigChange = (e) => {
-        const { name, value } = e.target;
-        setS3Config(prev => ({ ...prev, [name]: value }));
-    };
-
-    const handleSaveS3Config = async () => {
-        setIsSavingS3Config(true);
-        // Validation basique côté client
-        if (!s3Config.bucketName || !s3Config.accessKeyId || !s3Config.region) {
-            addNotification({ type: 'error', message: t('backup.s3config.validationError', 'Le nom du bucket, l\'Access Key ID et la Région sont requis.') });
-            setIsSavingS3Config(false);
-            return;
-        }
-
-        try {
-            const payload = { ...s3Config };
-            // N'envoyer la clé secrète que si elle a été modifiée
-            if (!payload.secretAccessKey) {
-                delete payload.secretAccessKey;
-            }
-
-            const response = await fetch('/api/user/s3-config', { // Endpoint pour sauvegarder la config S3
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    // Les en-têtes d'authentification (_user, Authorization) sont gérés globalement par le fetch wrapper si tu en as un, sinon ajoute-les ici
-                    // Exemple:
-                    // '_user': me?.username,
-                    // 'Authorization': `Bearer ${me?.token}`,
-                },
-                body: JSON.stringify(payload),
-            });
-            const result = await response.json();
-            if (response.ok && result.success) {
-                addNotification({ status: 'completed', title: t('backup.s3config.saveSuccess', 'Configuration S3 enregistrée avec succès.') });
-            } else {
-                addNotification({ status: 'error', title: result.error || t('backup.s3config.saveError', 'Erreur lors de l\'enregistrement de la configuration S3.') });
-            }
-        } catch (error) {
-            addNotification({ status: 'error', title: t('backup.s3config.saveError', 'Erreur lors de l\'enregistrement de la configuration S3.') });
-            console.error("Error saving S3 config:", error);
-        } finally {
-            setIsSavingS3Config(false);
-        }
-    };
-
-
     if (!isOpen) {
         return null;
     }
@@ -110,71 +36,8 @@ const RestoreConfirmationModal = ({ isOpen, onClose, onConfirm, showS3Config = f
                             <Trans i18nKey="btns.cancel">Annuler</Trans>
                         </Button>
                     </div>
-                    <div className={"flex flex-centered actions"}>
-                        {!showConfig && (<NavLink onClick={() => setConfigVisible(true)}><Trans i18nKey={"backup.s3config.title"}></Trans></NavLink>)}
-                    </div>
                 </>
 
-                {showConfig && (<>
-                    <h2>{t('backup.s3config.title', 'Configuration du stockage S3')}</h2>
-                    <p><Trans i18nKey="backup.prez"></Trans></p>
-                    <form className="s3-config-form space-y-4"> {/* Ajout de space-y pour l'espacement vertical */}
-                        <TextField
-                            name="bucketName"
-                            className={"flex flex-1"}
-                            label={t('backup.s3config.bucketName', 'Nom du Bucket S3')}
-                            value={s3Config.bucketName}
-                            onChange={handleS3ConfigChange}
-                            placeholder="my-bucket-name"
-                            required
-                        />
-                        <TextField
-                            name="accessKeyId"
-                            className={"flex flex-1"}
-                            label={t('backup.s3config.accessKeyId', 'Access Key ID AWS')}
-                            value={s3Config.accessKeyId}
-                            onChange={handleS3ConfigChange}
-                            placeholder="AKIAIOSFODNN7EXAMPLE"
-                            required
-                        />
-                        <TextField
-                            name="secretAccessKey"
-                            className={"flex flex-1"}
-                            label={t('backup.s3config.secretAccessKey', 'Secret Access Key AWS')}
-                            type="password" // Important pour masquer la clé
-                            value={s3Config.secretAccessKey}
-                            onChange={handleS3ConfigChange}
-                            placeholder={t('backup.s3config.secretPlaceholder', 'Laisser vide pour ne pas modifier')} />
-                        <TextField
-                            name="region"
-                            className={"flex flex-1"}
-                            label={t('backup.s3config.region', 'Région AWS')}
-                            value={s3Config.region}
-                            onChange={handleS3ConfigChange}
-                            placeholder="eu-west-3"
-                            required
-                        />
-                        <TextField
-                            name="pathPrefix"
-                            label={t('backup.s3config.pathPrefix', 'Préfixe de chemin (Optionnel)')}
-                            value={s3Config.pathPrefix}
-                            onChange={handleS3ConfigChange}
-                            placeholder="saves/my-app/"
-                            help={t('backup.s3config.pathPrefixHelp', 'Ex: "mon-dossier/". Laissez vide pour la racine du bucket.')}
-                        />
-                        <div
-                            className="modal-actions flex justify-end space-x-2 mt-4"> {/* Flex pour aligner les boutons */}
-                            <Button onClick={handleSaveS3Config} disabled={isSavingS3Config}
-                                    className="btn-primary"> {/* Classe btn-primary pour le bouton principal */}
-                                {isSavingS3Config ? t('btns.saving', 'Enregistrement...') : t('btns.save', 'Enregistrer la configuration S3')}
-                            </Button>
-                            <Button onClick={onClose} className="btn-secondary">
-                                <Trans i18nKey="btns.cancel">Annuler</Trans>
-                            </Button>
-                        </div>
-                    </form>
-                </>)}
-
             </div>
         </Dialog>
     );

package/client/src/filter.js

@@ -53,6 +53,8 @@ export const MONGO_CALC_OPERATORS = {
     $ln: { label: 'ln', multi: false },
     $log10: { label: 'log', multi: false },
     $concat: { label: 'concat', multi: true },
+
+    // Date-specific
     $year: { label: 'year', multi: false, isDate: true },
     $month: { label: 'month', multi: false, isDate: true },
     $dayOfMonth: { label: 'dayOfMonth', multi: false, isDate: true },

package/client/src/hooks/useTutorials.jsx

@@ -6,7 +6,7 @@ import { tutorialsConfig } from '../tutorials.js';
 import { useTranslation } from 'react-i18next';
 import { useCallback, useEffect, useMemo, useRef } from 'react';
 import useLocalStorage from "./useLocalStorage.js";
-import { event_off, event_on } from "../../../src/core.js";
+import {Event} from "../../../src/events.js";
 
 /**
  * Hook pour gérer la logique des tutoriels multi-étapes.
@@ -205,10 +205,10 @@ export const useTutorials = () => {
 
         console.log(me.activeTutorial + new Date().getMilliseconds());
         const eventTypes = ['API_ADD_DATA', 'API_EDIT_DATA', 'API_DELETE_DATA'];
-        eventTypes.forEach(type => event_on(type, handleDataChange));
+        eventTypes.forEach(type => Event.Listen(type, handleDataChange, "custom", "data"));
 
         return () => {
-            eventTypes.forEach(type => event_off(type, handleDataChange));
+            eventTypes.forEach(type => Event.RemoveCallback(type, handleDataChange, "custom", "data"));
         };
     }, [me?.activeTutorial]);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "data-primals-engine",
-  "version": "1.2.0",
-  "description": "data-primals-engine is the package responsible from handling large amount of data in a practical and performant way. It can handle large amount of data in a practical and performant way. It can also get workflow models working (for automation), and fully supports internationalisation.",
+  "version": "1.2.2",
+  "description": "data-primals-engine is a package responsible from handling large amount of data using MongoDB in a practical and performant way. It can also get workflow models working (for automation), and fully supports internationalisation. It also has integrated AI assistant.",
   "main": "src/engine.js",
   "type": "module",
   "scripts": {
@@ -30,7 +30,8 @@
   "resolutions": {
     "tar-fs": "3.0.9",
     "on-headers": "1.1.0",
-    "brace-expansion": "2.0.2"
+    "brace-expansion": "2.0.2",
+    "prismjs": "1.30.0"
   },
   "repository": {
     "type": "git",

package/src/core.js

@@ -9,6 +9,12 @@ export function escapeRegex(string) {
     return string.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&');
 }
 
+export function escapeHtml(string){
+    return string.replace(/(javascript|data|vbscript):/gi, '').replace(/[^\w-_. ]/gi, function (c) {
+        return `&#${c.charCodeAt(0)};`;
+    });
+}
+
 export const isDate = dt => String(new Date(dt)) !== 'Invalid Date'
 
 export const safeAssignObject = (obj, key, value) => {

package/src/data.js

@@ -5,21 +5,21 @@ import {mainFieldsTypes} from "./constants.js";
 
 const IV_LENGTH = 16;
 export function encryptValue(text) {
-    if (!process.env.S3_CONFIG_ENCRYPTION_KEY) throw new Error("S3_CONFIG_ENCRYPTION_KEY is not set");
+    if (!process.env.ENCRYPTION_KEY) throw new Error("ENCRYPTION_KEY is not set");
     let iv = crypto.randomBytes(IV_LENGTH);
-    let cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(process.env.S3_CONFIG_ENCRYPTION_KEY), iv);
+    let cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(process.env.ENCRYPTION_KEY), iv);
     let encrypted = cipher.update(text);
     encrypted = Buffer.concat([encrypted, cipher.final()]);
     return iv.toString('hex') + ':' + encrypted.toString('hex');
 }
 
 export function decryptValue(text) {
-    if (!process.env.S3_CONFIG_ENCRYPTION_KEY) throw new Error("S3_CONFIG_ENCRYPTION_KEY is not set");
+    if (!process.env.ENCRYPTION_KEY) throw new Error("ENCRYPTION_KEY is not set");
     if (!text || typeof text !== 'string' || !text.includes(':')) return text; // ou throw error
     let textParts = text.split(':');
     let iv = Buffer.from(textParts.shift(), 'hex');
     let encryptedText = Buffer.from(textParts.join(':'), 'hex');
-    let decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(process.env.S3_CONFIG_ENCRYPTION_KEY), iv);
+    let decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(process.env.ENCRYPTION_KEY), iv);
     let decrypted = decipher.update(encryptedText);
     decrypted = Buffer.concat([decrypted, decipher.final()]);
     return decrypted.toString();

package/src/defaultModels.js

@@ -46,6 +46,39 @@ export const defaultModels = {
             { name: 'tokens', type: 'relation', multiple: true, relation: 'token' }
         ]
     },
+    userPermission: {
+        "name": "userPermission",
+        "description": "Gère les exceptions aux permissions des rôles pour un utilisateur (ajouts ou retraits, permanents ou temporaires).",
+        "fields": [
+            {
+                "name": "user",
+                "type": "relation",
+                "relation": "user",
+                "required": true,
+                "index": true
+            },
+            {
+                "name": "permission",
+                "type": "relation",
+                "relation": "permission",
+                "required": true,
+                "index": true
+            },
+            {
+                "name": "isGranted",
+                "type": "boolean",
+                "required": true,
+                "hint": "True pour accorder la permission, False pour la révoquer explicitement."
+            },
+            {
+                "name": "expiresAt",
+                "type": "datetime",
+                "required": false,
+                "index": true,
+                "hint": "Si défini, l'exception (l'octroi ou la révocation) est temporaire."
+            }
+        ]
+    },
     token: {
         name: 'token',
         "description": "",

package/src/email.js

@@ -1,7 +1,7 @@
 import process from "node:process";
 import nodemailer from "nodemailer";
 import juice from "juice";
-import {event_trigger} from "./core.js";
+import {Event} from "./events.js";
 import {emailDefaultConfig} from "./constants.js";
 
 // Le transporteur par défaut, utilisé si aucune config spécifique n'est fournie.
@@ -52,7 +52,7 @@ export const sendEmail = async (email = "", data, smtpConfig = null, lang, tpl =
     // Choisir le transporteur à utiliser
     const transporter = smtpConfig ? createTransporter(smtpConfig||emailDefaultConfig) : defaultTransporter;
 
-    if (tpl === null) tpl = event_trigger("sendEmail:template",data, lang);
+    if (tpl === null) tpl = Event.Trigger("sendEmail:template", "system", "calls", data, lang);
     let html = tpl;
     try {
         html = juice(tpl);

package/src/engine.js

@@ -19,6 +19,7 @@ import {DefaultUserProvider} from "./providers.js";
 import formidableMiddleware from 'express-formidable';
 import sirv from "sirv";
 import * as tls from "node:tls";
+import {Event} from "./events.js";
 
 // Constants
 const isProduction = process.env.NODE_ENV === 'production'
@@ -79,13 +80,13 @@ export const Engine = {
     Create: async (options = { app : null}) => {
         const engine = GameObject.Create("Engine");
         console.log("Creating engine", Config.Get('modules'));
-        engine.addComponent(Logger);
+        const logger = engine.addComponent(Logger);
 
         engine.userProvider = new DefaultUserProvider(engine);
 
         engine.setUserProvider = (providerInstance) => {
             engine.userProvider = providerInstance;
-            engine.getComponent(Logger).info(`Custom UserProvider '${providerInstance.constructor.name}' has been set.`);
+            logger.info(`Custom UserProvider '${providerInstance.constructor.name}' has been set.`);
         };
 
         if (!options.app) {
@@ -130,9 +131,6 @@ export const Engine = {
             return engine._modules.find(m => m.module === module);
         };
 
-
-        const logger = engine.getComponent(Logger);
-
         const importModule = async (module) => {
             const moduleA = await import(module);
             if (moduleA.onInit){
@@ -147,13 +145,13 @@ export const Engine = {
 
         await Promise.all(Config.Get('modules', []).map(async module => {
             try {
-                if( fs.existsSync(module)){
+                if( fs.existsSync(module) ){
                     return await importModule(module);
                 }else {
                     return await importModule('./modules/' + module + ".js");
                 }
             } catch (e){
-                console.log('ERROR at loading module '+ module + ' in /modules dir.', e.stack);
+                logger.info('ERROR at loading module '+ module, e.stack);
             }
         })).then(async e => {
             engine._modules = e;
@@ -202,10 +200,13 @@ export const Engine = {
                 });
                 process.exit(1);
             });
+
+            Event.Trigger("OnServerStart", "event", "system", engine);
         }
 
         engine.stop = async () => {
             await server.close();
+            Event.Trigger("OnServerStop", "event", "system", engine);
         };
 
         async function setupInitialModels() {
@@ -228,9 +229,11 @@ export const Engine = {
                     logger.info('Model loaded (' + model.name + ')');
             }
             logger.info("All models loaded.");
+            Event.Trigger("OnModelsLoaded", "event", "system", engine, dbModels);
         }
         engine.resetModels = async () => {
             await deleteModels();
+            Event.Trigger("OnModelsDeleted", "event", "system", engine);
         };
         return engine;
     }

package/src/events.js

@@ -4,7 +4,9 @@ const events = {};
 const eventLayerSystems = {
     "priority": ["high", "medium", "low"],
     "log": ["info", "debug", "warn", "error", "critical"],
-    "system": ["calls"]
+    "system": ["calls", "users"],
+    "event": ["system","user"],
+    "custom": ["data"]
 };
 
 
@@ -13,11 +15,12 @@ export const Event = {
     Trigger: (name, system = "priority", layer = "medium", ...args) => {  // Ajout des arguments system et layer
         if (!events[system] || !events[system][name] || (layer && !events[system][name][layer])) {
             //console.warn(`No trigger found for ${name} in system ${system} layer ${layer}`);
-            return;
+            return null;
         }
 
         const systemsToProcess = system ? [system] : Object.keys(events); // Si system est spécifié, on cible ce système uniquement, sinon tous les systèmes
 
+        let ret = null;
         for (const currentSystem of systemsToProcess) {
             if (events[currentSystem] && events[currentSystem][name]) {
                 const layersToProcess = layer ? [layer] : eventLayerSystems[currentSystem] || Object.keys(events[currentSystem][name]); // Si layer est spécifié, on cible cette couche, sinon toutes les couches ou celles définies dans eventLayerSystems
@@ -27,7 +30,25 @@ export const Event = {
                         if (events[currentSystem][name][currentLayer]) {
                             for (const callback of events[currentSystem][name][currentLayer]) {
                                 try {
-                                    callback(...args);
+                                    const res = callback(...args);
+                                    if (typeof res === "object" && !Array.isArray(res)) {
+                                        if (typeof ret !== "object") ret = {};
+                                        ret = {...ret, ...res};
+                                    } else if (Array.isArray(res)) {
+                                        if (!Array.isArray(ret)) ret = [];
+                                        ret = ret.concat(res);
+                                    } else if (typeof res === "string") {
+                                        if (typeof ret !== "string") ret = "";
+                                        ret += res;
+                                    } else if (typeof res === "number") {
+                                        if (typeof ret !== "number") ret = 0;
+                                        ret += res;
+                                    } else if (typeof res === "boolean") {
+                                        if (typeof ret !== "boolean") ret = true;
+                                        ret = res && ret;
+                                    } else {
+                                        ret = res || ret;
+                                    }
                                 } catch (error) {
                                     console.error(`Error in callback for event ${name} in system ${currentSystem} layer ${currentLayer}:`, error);
                                 }
@@ -37,6 +58,7 @@ export const Event = {
                 }
             }
         }
+        return ret;
     },
     Listen: (name = "", callback = () => {}, system = "priority", layer = "medium") => {
         const validSystems = Object.keys(eventLayerSystems); // Récupération des clés pour une vérification plus performante

package/src/modules/bucket.js

@@ -3,7 +3,6 @@ import AWS from "aws-sdk";
 import fs from "node:fs";
 import path from "node:path";
 import {decryptValue, encryptValue} from "../data.js";
-import {MongoClient} from "../engine.js";
 import {loadFromDump, validateRestoreRequest} from "./data.js";
 import {Logger} from "../gameObject.js";
 import {middlewareAuthenticator, userInitiator} from "./user.js";
@@ -12,6 +11,7 @@ import crypto from "node:crypto";
 import i18n from "../../src/i18n.js";
 import {sendEmail} from "../email.js";
 import {throttleMiddleware} from "../middlewares/throttle.js";
+import {getCollectionForUser} from "./mongodb.js";
 
 const restoreRequests = {};
 
@@ -54,14 +54,77 @@ const getDefaultS3Config = () => {
         bucketName: process.env.AWS_BUCKET || awsDefaultConfig.bucketName
     };
 }
-const getS3Client = (s3Config) => {
 
-    const decryptedSecretAccessKey = decryptValue(s3Config.secretAccessKey);
+/**
+ * Récupère la configuration S3 depuis les variables d'environnement de l'utilisateur en base de données.
+ * @param {object} user - L'objet utilisateur.
+ * @returns {Promise<object>} - Un objet contenant la configuration S3 trouvée pour l'utilisateur.
+ */
+async function _getUserS3ConfigFromDb(user) {
+    if (!user || !user.username) {
+        return {}; // Pas d'utilisateur, pas de configuration spécifique.
+    }
+
+    try {
+        const collection = await getCollectionForUser(user);
+        const userEnvVars = await collection.find({
+            _model: 'env',
+            _user: user.username,
+            // On ne cherche que les clés pertinentes pour optimiser la requête
+            key: { $in: ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_REGION', 'AWS_BUCKET_NAME'] }
+        }).toArray();
+
+        // Transforme le tableau de documents [{key, value}, ...] en un objet de configuration.
+        return userEnvVars.reduce((config, envVar) => {
+            if (envVar.key === 'AWS_ACCESS_KEY_ID') config.accessKeyId = envVar.value;
+            if (envVar.key === 'AWS_SECRET_ACCESS_KEY') config.secretAccessKey = envVar.value; // La clé est déjà chiffrée en BDD
+            if (envVar.key === 'AWS_REGION') config.region = envVar.value;
+            if (envVar.key === 'AWS_BUCKET_NAME') config.bucketName = envVar.value;
+            return config;
+        }, {});
 
-    const defaultConfig = getDefaultS3Config();
+    } catch (error) {
+        logger.error(`Failed to fetch user S3 config from DB for ${user.username}:`, error);
+        return {}; // Retourne un objet vide en cas d'erreur pour utiliser le fallback.
+    }
+}
+
+/**
+ * Récupère la configuration S3 effective en priorisant celle de l'utilisateur
+ * puis en se rabattant sur la configuration globale de l'environnement.
+ * C'est la fonction à utiliser pour toute opération S3.
+ * @param {object} user - L'objet utilisateur.
+ * @returns {Promise<object>} - L'objet de configuration S3 final.
+ */
+export async function getUserS3Config(user) {
+    // 1. Récupérer la configuration globale par défaut
+    const defaultConfig = {
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        region: process.env.AWS_REGION || awsDefaultConfig.region,
+        bucketName: process.env.AWS_BUCKET_NAME || awsDefaultConfig.bucketName
+    };
+
+    // 2. Récupérer la configuration spécifique de l'utilisateur
+    const userConfig = await _getUserS3ConfigFromDb(user);
+
+    if( userConfig.bucketName && userConfig.accessKeyId && userConfig.secretAccessKey) {
+        // 3. Fusionner les configurations, en donnant la priorité à celle de l'utilisateur
+        return {
+            accessKeyId: userConfig.accessKeyId || defaultConfig.accessKeyId,
+            secretAccessKey: userConfig.secretAccessKey || defaultConfig.secretAccessKey,
+            region: userConfig.region || defaultConfig.region,
+            bucketName: userConfig.bucketName || defaultConfig.bucketName
+        };
+    }
+    console.log({defaultConfig})
+    return defaultConfig;
+}
+const getS3Client = (s3Config) => {
+
+    const decryptedSecretAccessKey = s3Config.secretAccessKey ? decryptValue(s3Config.secretAccessKey): undefined;
 
     return new AWS.S3({
-        ...defaultConfig,
         accessKeyId: s3Config.accessKeyId || defaultConfig.accessKeyId,
         secretAccessKey: decryptedSecretAccessKey ? decryptedSecretAccessKey : defaultConfig.secretAccessKey,
         region: s3Config.region || defaultConfig.region,
@@ -74,6 +137,10 @@ export const uploadToS3 = async (s3Config, filePath, remoteFilename) => {
     const fileContent = fs.readFileSync(filePath);
     const bucketPath = s3Config.pathPrefix ? `${s3Config.pathPrefix.replace(/\/$/, "")}/${remoteFilename}` : remoteFilename;
 
+    if( !s3.accessKeyId || !s3.secretAccessKey || !s3.bucketName) {
+        throw new Error('Missing S3 configuration');
+    }
+
     const params = {
         Bucket: s3Config.bucketName,
         Key: bucketPath,
@@ -90,6 +157,7 @@ export const uploadToS3 = async (s3Config, filePath, remoteFilename) => {
     }
 };
 
+
 export const listS3Backups = async (s3Config) => {
     const s3 = getS3Client(s3Config);
     const bucketPathPrefix = s3Config.pathPrefix ? `${s3Config.pathPrefix.replace(/\/$/, "")}/` : '';
@@ -133,6 +201,48 @@ export const downloadFromS3 = async (s3Config, s3FileKey, downloadPath) => {
     }
 };
 
+export const deleteFromS3 = async (s3Config, remoteFilename) => {
+    const s3 = getS3Client(s3Config);
+    const bucketPath = s3Config.pathPrefix ? `${s3Config.pathPrefix.replace(/\/$/, "")}/${remoteFilename}` : remoteFilename;
+
+    const params = {
+        Bucket: s3Config.bucketName,
+        Key: bucketPath
+    };
+
+    try {
+        await s3.deleteObject(params).promise();
+        console.log(`Fichier supprimé avec succès de S3 : ${bucketPath}`);
+    } catch (err) {
+        console.error("Erreur lors de la suppression sur S3 :", err);
+        throw err;
+    }
+};
+
+/**
+ * Crée un flux de lecture pour un objet depuis un bucket S3.
+ * @param {object} s3Config - La configuration S3 (bucketName, accessKeyId, secretAccessKey, region).
+ * @param {string} s3Key - La clé (nom du fichier) de l'objet sur S3.
+ * @returns {import('stream').Readable} - Le flux de lecture de l'objet S3.
+ */
+export const getS3Stream = (s3Config, s3Key) => {
+    if (!s3Config || !s3Config.bucketName || !s3Key) {
+        throw new Error("La configuration S3 et la clé de l'objet sont requises pour créer un flux.");
+    }
+
+    // On utilise la fonction existante qui gère le déchiffrement !
+    const s3 = getS3Client(s3Config);
+
+    const params = {
+        Bucket: s3Config.bucketName,
+        Key: s3Key
+    };
+
+    // getObject().createReadStream() retourne directement un flux lisible.
+    // Les erreurs (ex: objet non trouvé) seront émises sur l'événement 'error' de ce flux.
+    return s3.getObject(params).createReadStream();
+};
+
 const throttle = throttleMiddleware(maxBytesPerSecondThrottleData);
 
 let engine, logger;