data-primals-engine 1.2.1 → 1.2.3

package/src/defaultModels.js

@@ -543,19 +543,6 @@ export const defaultModels = {
             { name: 'createdAt', type: 'datetime', required: true }
         ]
     },
-    campaign: {
-        name: 'campaign',
-        "description": "",
-        fields: [
-            { name: 'name', type: 'string_t', required: true },
-            { name: 'description', type: 'richtext' },
-            { name: 'startDate', type: 'datetime' },
-            { name: 'endDate', type: 'datetime' },
-            { name: 'type', type: 'enum', items: ['email', 'sms', 'advertisement', 'promotion'] },
-            { name: 'status', type: 'enum', items: ['planified', 'in_progress', 'finished', 'cancelled'] },
-            { name: 'budget', type: 'number' }
-        ]
-    },
     review: {
         name: "review",
         "description": "",
@@ -1014,7 +1001,7 @@ export const defaultModels = {
             { name: 'owner', type: 'relation', relation: 'user', required: false },
             { name: 'startedAt', type: 'datetime', required: true, hint: "Timestamp when the workflow run began." },
             { name: 'completedAt', type: 'datetime', hint: "Timestamp when the workflow run finished (successfully or failed)." },
-            { name: 'error', type: 'string', maxlength: 4096, hint: "Error message if the workflow run failed." }
+            { name: 'log', type: 'string', maxlength: 4096, hint: "Error message if the workflow run failed." }
         ]
     },
     dashboard:{

package/src/email.js

@@ -1,17 +1,17 @@
 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.
 const defaultTransporter = nodemailer.createTransport({
-    host: "mail.smtp2go.com",
-    port: 587,
+    host: process.env.SMTP_HOST,
+    port: process.env.SMTP_PORT || 587,
     secure: false,
     auth: {
-        user: process.env.MAIL_USER,
-        pass: process.env.MAIL_PASS
+        user: process.env.SMTP_USER,
+        pass: process.env.SMTP_PASS
     }
 });
 
@@ -52,7 +52,9 @@ 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);
+    Event.Listen("OnEmailTemplate", (data, lang) => data.content, "event", "system");
+
+    if (tpl === null) tpl = Event.Trigger("OnEmailTemplate", "event", "system", data, lang);
     let html = tpl;
     try {
         html = juice(tpl);

package/src/engine.js

@@ -13,12 +13,13 @@ import {
 import http from "http";
 import cookieParser from "cookie-parser";
 import requestIp from 'request-ip';
-import {createModel, deleteModels, getModels, validateModelStructure} from "./modules/data.js";
+import {createModel, deleteModels, getModels, installAllPacks, validateModelStructure} from "./modules/data.js";
 import {defaultModels} from "./defaultModels.js";
 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;
@@ -177,6 +175,7 @@ export const Engine = {
             server.listen(port);
 
             await setupInitialModels();
+            await installAllPacks();
 
             if (cb)
                 await cb();
@@ -202,10 +201,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 +230,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,8 +58,9 @@ export const Event = {
                 }
             }
         }
+        return ret;
     },
-    Listen: (name = "", callback = () => {}, system = "priority", layer = "medium") => {
+    Listen: (name = "", callback, system = "priority", layer = "medium") => {
         const validSystems = Object.keys(eventLayerSystems); // Récupération des clés pour une vérification plus performante
         if (!validSystems.includes(system)) {
             throw new Error(`System '${system}' does not exist. Valid systems are: ${validSystems.join(', ')}`); // Message d'erreur plus informatif

package/src/filter.js

@@ -0,0 +1,221 @@
+/**
+ * Evaluates a single condition against form data.
+ * @param {object} currentModelDef - The definition of the current model.
+ * @param {object} condition - The condition to evaluate.
+ * @param {object} formData - The form data.
+ * @param {object[]} allModels - An array of all model definitions.
+ * @param {object} user - The current user.
+ * @returns {boolean} - True if the condition is met, false otherwise.
+ */
+const evaluateSingleCondition = (currentModelDef, condition, formData, allModels, user) => {
+    // Condition est directement un filtre MongoDB, donc on l'applique
+    // en utilisant les opérateurs et les valeurs qu'il contient.
+
+    if (!condition || typeof condition !== 'object') {
+        console.warn("[Client Eval] Condition is not an object:", condition);
+        return true; // Permissive default
+    }
+
+    // Si la condition est de la forme {field: value}, on la transforme en {$eq: value}
+    if (!Object.keys(condition)[0].startsWith('$') && typeof condition[Object.keys(condition)[0]] !== 'object') {
+        const fieldName = Object.keys(condition)[0];
+        const value = condition[fieldName];
+        return evaluateSingleCondition(currentModelDef, {[fieldName]: {$eq: value}}, formData, allModels, user);
+    }
+
+    // Gestion des opérateurs d'agrégation (commencent par $)
+    const operator = Object.keys(condition)[0];
+    if (operator === '$eq' && Array.isArray(condition[operator])) {
+        // Cas spécial pour {$eq: ['$field', value]}
+        const [fieldPath, expectedValue] = condition[operator];
+        if (typeof fieldPath === 'string' && fieldPath.startsWith('$')) {
+            const fieldName = fieldPath.substring(1); // Enlève le $ devant
+            return formData[fieldName] == expectedValue;
+        }
+    }
+
+    // Si la condition contient des opérateurs logiques, on les gère ici
+    if (condition.$and || condition.$or || condition.$not || condition.$nor) {
+        console.warn("[Client Eval] Condition logique détectée dans evaluateSingleCondition, ce n'est pas attendu. Devrait être géré par isConditionMet.");
+        return true; // Permissive default
+    }
+
+    if (condition.$find) {
+        const fieldName = Object.keys(condition)[0];
+        const fieldValue = formData[fieldName];
+        const findCondition = condition.$find;
+
+        if (!Array.isArray(fieldValue)) return false;
+
+        return fieldValue.some(item => {
+            // Gestion spéciale pour la syntaxe $eq: ["$$this.field", value]
+            if (findCondition.$eq && Array.isArray(findCondition.$eq)) {
+                const [fieldPath, value] = findCondition.$eq;
+                if (fieldPath.startsWith("$$this.")) {
+                    const fieldToCheck = fieldPath.replace("$$this.", "");
+                    return item[fieldToCheck] == value;
+                }
+            }
+
+            // Sinon, évaluation normale
+            const tempData = { ...item };
+            return evaluateSingleCondition(currentModelDef, findCondition, tempData, allModels, user);
+        });
+    }
+
+    // Si la condition contient un opérateur $exists, on le gère ici
+    if (condition.$exists !== undefined) {
+        const fieldName = Object.keys(condition)[0]; // Récupérer le nom du champ
+        const shouldExist = condition.$exists; // Récupérer la valeur de $exists (true ou false)
+        const exists = Object.prototype.hasOwnProperty.call(formData, fieldName) && formData[fieldName] !== undefined && formData[fieldName] !== null;
+        return exists === shouldExist;
+    }
+
+    // Si la condition contient un opérateur $find, on le gère ici
+    if (condition.$find) {
+        // Récupérer le nom du champ
+        const fieldName = Object.keys(condition)[0];
+        const fieldValue = formData[fieldName];
+        try {
+            // Assuming evaluateSingleCondition handles $find
+            return evaluateSingleCondition(currentModelDef, condition.$find, formData, allModels, user);
+        } catch (error) {
+            console.error("Error evaluating $find condition:", condition, error);
+            return false;
+        }
+    }
+
+    // Récupérer le nom du champ et la condition
+    const fieldName = Object.keys(condition)[0];
+    const fieldValue = condition[fieldName];
+
+    // Récupérer la définition du champ
+    const fieldDef = currentModelDef?.fields.find(f => f.name === fieldName);
+
+    // Si la définition du champ n'est pas trouvée, on retourne true
+    if (!fieldDef) {
+        console.warn(`[Client Eval] Field definition not found for field: ${fieldName}`);
+        return true; // Permissive default
+    }
+
+    let targetValue = formData[fieldName];
+    let processedConditionValue = fieldValue;
+
+    // 1. Handle $exists (on the first field)
+    // 2. Convert condition value based on operator's expected input type
+    const fieldType = fieldDef?.type; // Type of the first field
+
+    try {
+        processedConditionValue = convertValueType(fieldValue, fieldType);
+    } catch (e) {
+        logClientEvalWarning(`Error converting value type: ${e.message}`, condition);
+        return false;
+    }
+
+    return evaluateComparison(fieldValue, targetValue, processedConditionValue, condition);
+
+    function logClientEvalWarning(message, details) {
+        console.warn(`[Client Eval] ${message}:`, details);
+    }
+
+    function convertValueType(value, inputType) {
+        switch (inputType) {
+        case 'number':
+            const numValue = parseFloat(value);
+            if (isNaN(numValue)) {
+                throw new Error(`Invalid number value: ${value}`);
+            }
+            return numValue;
+        case 'boolean':
+            return String(value).toLowerCase() === 'true';
+        case 'csv':
+            return String(value).split(',').map(item => item.trim()).filter(Boolean);
+        case 'text':
+        default:
+            return String(value);
+        }
+    }
+
+    function evaluateComparison(operator, targetValue, processedConditionValue, condition) {
+        try {
+            switch (typeof operator === 'object' ? Object.keys(operator)[0] : null) {
+            case '$eq': return targetValue == processedConditionValue;
+            case '$ne': return targetValue != processedConditionValue;
+            case '$gt': return targetValue > processedConditionValue;
+            case '$lt': return targetValue < processedConditionValue;
+            case '$gte': return targetValue >= processedConditionValue;
+            case '$lte': return targetValue <= processedConditionValue;
+            case '$regex':
+                if (typeof targetValue !== 'string') return false;
+                if (typeof processedConditionValue !== 'string') return false;
+                try {
+                    const regex = new RegExp(processedConditionValue, 'i');
+                    return regex.test(targetValue);
+                } catch (e) {
+                    logClientEvalWarning(`Invalid regex pattern: ${processedConditionValue}`, condition);
+                    return false;
+                }
+            case '$in':
+                return Array.isArray(processedConditionValue) && processedConditionValue.includes(String(targetValue));
+            case '$nin':
+                return !Array.isArray(processedConditionValue) || !processedConditionValue.includes(String(targetValue));
+            default:
+                logClientEvalWarning(`Unhandled operator in client evaluation logic: ${operator}`, condition);
+                return true; // Permissive default
+            }
+        } catch (evalError) {
+            logClientEvalWarning(`Error during client condition evaluation: ${operator}, targetValue=${targetValue}, processedConditionValue=${processedConditionValue}`, condition);
+            return false;
+        }
+    }
+};
+
+export const isConditionMet = (model, cond, formData, allModels, user) => {
+    const condition = cond;
+
+    if (!condition) return true;
+
+    // Cas 1: Condition simple {field: value} → transformée en {field: {$eq: value}}
+    if (typeof condition === 'object' && !Array.isArray(condition)) {
+        const keys = Object.keys(condition);
+        if (keys.length === 1 && !keys[0].startsWith('$') &&
+            typeof condition[keys[0]] !== 'object') {
+            const simpleCondition = {
+                [keys[0]]: {$eq: condition[keys[0]]}
+            };
+            return evaluateSingleCondition(model, simpleCondition, formData, allModels, user);
+        }
+    }
+
+    // Cas 2: Opérateurs logiques ($and, $or, $not, $nor)
+    if (condition.$and && Array.isArray(condition.$and)) {
+        if (condition.$and.length === 0) return true;
+        return condition.$and.every(sub => isConditionMet(model, sub, formData, allModels, user));
+    }
+
+    if (condition.$or && Array.isArray(condition.$or)) {
+        if (condition.$or.length === 0) return false;
+        return condition.$or.some(sub => isConditionMet(model, sub, formData, allModels, user));
+    }
+
+    if (condition.$not) {
+        return !isConditionMet(model, condition.$not, formData, allModels, user);
+    }
+
+    if (condition.$nor && Array.isArray(condition.$nor)) {
+        if (condition.$nor.length === 0) return true;
+        return !condition.$nor.some(sub => isConditionMet(model, sub, formData, allModels, user));
+    }
+
+    // Cas 3: Syntaxe d'agrégation {$eq: ['$field', value]}
+    if (Object.keys(condition).length === 1) {
+        const operator = Object.keys(condition)[0];
+        if (operator.startsWith('$') && operator !== '$find' &&
+            Array.isArray(condition[operator])) {
+            return evaluateSingleCondition(model, condition, formData, allModels, user);
+        }
+    }
+
+    // Cas 4: Tous les autres cas (conditions normales avec opérateurs)
+    return evaluateSingleCondition(model, condition, formData, allModels, user);
+};

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;