data-primals-engine 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-primals-engine",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "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.",
   "main": "src/engine.js",
   "type": "module",

package/server.js

@@ -13,11 +13,20 @@ const bench = GameObject.Create("Benchmark");
 const timer = bench.addComponent(BenchmarkTool);
 timer.start();
 
-const engine = Engine.Create();
+
+const engine = await Engine.Create();
+
+if (process.argv.length === 3) {
+    let arg = process.argv[2];
+    if( arg === 'reset-models'){
+        console.log("resetting models");
+        await engine.resetModels();
+    }
+}
 
 const port = process.env.PORT || 7633;
 engine.start(port, async (r) => {
     const logger = engine.getComponent(Logger);
-
+    console.log("Server started on port" + port);
     timer.stop();
 });

package/src/data.js

@@ -29,8 +29,12 @@ export const isLocalUser = (user) => {
     return user && user._model === 'user' && typeof(user._user) === 'string' && user._user.trim() !== '';
 };
 
+export const isDemoUser = (user) => {
+    return /^demo[0-9]{1,2}$/.test(user?.username);
+}
+
 export function getUserHash(user) {
-    if( /^demo[0-9]{1,2}$/.test(user?.username) ){
+    if( isDemoUser(user) ){
         return user.username;
     }
     return user ? (
@@ -419,8 +423,9 @@ export const getFieldValueHash = (model, data) => {
  * @param {array} allModels - Un tableau contenant les définitions de TOUS les modèles du système.
  * @returns {string} - La chaîne de caractères représentant la donnée.
  */
-export const getDataAsString = (model, data, t, allModels, extended=false) => {
-
+export const getDataAsString = (model, data, tr, allModels, extended=false) => {
+    const { t, i18n} = tr;
+    const lang = (i18n.resolvedLanguage || i18n.language).split(/[-_]/)?.[0];
     // Cas de base : si le modèle ou les données sont manquants, on ne peut rien faire.
     if (!model || !data) {
         return '';
@@ -464,7 +469,6 @@ export const getDataAsString = (model, data, t, allModels, extended=false) => {
             const relatedModel = allModels?.find(m => m.name === fieldDef.relation);
             if (!relatedModel) return `[${fieldDef.relation}]`; // Modnon trouvé
 
-            console.log({relatedModel, value});
             // Si la relation est multiple (un tableau d'objets)
             if (Array.isArray(value)) {
                 return value
@@ -474,10 +478,16 @@ export const getDataAsString = (model, data, t, allModels, extended=false) => {
             }
             // Si la relation est simple (un seul objet)
             else if (typeof value === 'object') {
-                console.log({relatedModel, value});
                 return getDataAsString(relatedModel, value, t, allModels); // Appel récursif
             }
         }
+
+        if(fieldDef.type === 'datetime'){
+            return new Date(value).toLocaleDateString(lang, {year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric'});
+        }
+        if(fieldDef.type === 'date'){
+            return new Date(value).toLocaleDateString(lang, {year: 'numeric', month: 'numeric', day: 'numeric'});
+        }
         // --- FIN DE LA NOUVELLE LOGIQUE ---
 
         // Logique existante pour les autres types de champs

package/src/email.js

@@ -2,6 +2,8 @@ import { translations } from "data-primals-engine/i18n";
 import process from "node:process";
 import nodemailer from "nodemailer";
 import juice from "juice";
+import {event_trigger} from "./core.js";
+import {emailDefaultConfig} from "./constants.js";
 
 // Le transporteur par défaut, utilisé si aucune config spécifique n'est fournie.
 const defaultTransporter = nodemailer.createTransport({

package/src/engine.js

@@ -8,7 +8,7 @@ import {cookiesSecret, dbName} from "./constants.js";
 import http from "http";
 import cookieParser from "cookie-parser";
 import requestIp from 'request-ip';
-import {createModel, getModels, validateModelStructure} from "./modules/data.js";
+import {createModel, deleteModels, getModels, validateModelStructure} from "./modules/data.js";
 import {defaultModels} from "./defaultModels.js";
 import {DefaultUserProvider} from "./providers.js";
 import formidableMiddleware from 'express-formidable';
@@ -25,9 +25,10 @@ export const MongoDatabase = MongoClient.db(dbName);
 
 
 export const Engine = {
-    Create:  (options) => {
+    Create: async (options) => {
         const engine = GameObject.Create("Engine");
         console.log("Creating engine", Config.Get('modules'));
+        engine.addComponent(Logger);
 
         engine.userProvider = new DefaultUserProvider(engine);
 
@@ -71,10 +72,38 @@ 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){
+                await moduleA.onInit(engine);
+                return {...moduleA, module};
+            }else {
+                const mod = moduleA.default();
+                await mod?.onInit(engine);
+                return { ...mod, module};
+            }
+        };
+
+        await Promise.all(Config.Get('modules').map(async module => {
+            try {
+                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);
+            }
+        })).then(async e => {
+            engine._modules = e;
+            return Promise.resolve();
+        });
         let server;
         engine.start = async (port, cb) =>{
     // Use connect method to connect to the server
-            await MongoClient.connect();
 
             // Start http server
             server = http.createServer(app);
@@ -87,37 +116,11 @@ export const Engine = {
 
             server.listen(port);
 
-            const importModule = async (module) => {
-                const moduleA = await import(module);
-                if (moduleA.onInit){
-                    await moduleA.onInit(engine);
-                    return {...moduleA, module};
-                }else {
-                    const mod = moduleA.default();
-                    await mod?.onInit(engine);
-                    return { ...mod, module};
-                }
-            };
-
-            await Promise.all(Config.Get('modules').map(async module => {
-                try {
-                    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);
-                }
-            })).then(async e => {
-                engine._modules = e;
-                if (cb)
-                    return await cb();
-                return Promise.resolve();
-            });
-
             await setupInitialModels();
 
+            if (cb)
+                await cb();
+
             process.on('uncaughtException', function (exception) {
                 console.error(exception);
                 fs.appendFile('issues.txt', JSON.stringify({ code: exception.code, message: exception.message, stack: exception.stack }), function (err) {
@@ -128,14 +131,11 @@ export const Engine = {
                 process.exit(0);
             });
         }
-        engine.addComponent(Logger);
 
         engine.stop = async () => {
             await server.close();
         };
 
-        const logger = engine.getComponent(Logger);
-
         async function setupInitialModels() {
             logger.info("Validating structures of default models...");
             const ms = Object.values(Config.Get('defaultModels', defaultModels));
@@ -151,13 +151,15 @@ export const Engine = {
                     model.locked = true;
                     const r = await createModel(model);
                     dbModels.push({...model, _id: r.insertedId });
-                }
-                else
-                    logger.info('Model loaded (' + model.name + ')', {});
+                    logger.info('Model inserted (' + model.name + ')');
+                }else
+                logger.info('Model loaded (' + model.name + ')');
             }
             logger.info("All models loaded.");
         }
-
+        engine.resetModels = async () => {
+            await deleteModels();
+        };
        return engine;
     }
 }

package/src/gameObject.js

@@ -70,23 +70,21 @@ export class UsableBehaviour extends Behaviour {
 
     use() {
         Event.Trigger("GameObject.UsableBehavior.use",  "system", "calls", this);
-        // Logique d'utilisation (exemple)
-        console.log(this.gameObject.name + " a été utilisé !");
     }
 }
 
-const pilote = GameObject.Create("Pilote");
+const mainDriver = GameObject.Create("MainDrivers");
 
 // Exemple d'attachement de comportements
-pilote.addComponent(MovableBehaviour, 10);
-pilote.addComponent(UsableBehaviour);
+mainDriver.addComponent(MovableBehaviour, 10);
+mainDriver.addComponent(UsableBehaviour);
 
 // Accéder et utiliser les composants
-const movable = pilote.getComponent(MovableBehaviour);
+const movable = mainDriver.getComponent(MovableBehaviour);
 if (movable) {
     movable.update();
 }
-const usable = pilote.getComponent(UsableBehaviour);
+const usable = mainDriver.getComponent(UsableBehaviour);
 if (usable) {
     usable.use();
 }

package/src/modules/data.js

@@ -16,7 +16,7 @@ import {
     encryptValue,
     getDefaultForType,
     getFieldValueHash,
-    getUserId,
+    getUserId, isDemoUser,
     isLocalUser
 } from "../data.js";
 import {
@@ -88,6 +88,7 @@ import {
 import {assistantGlobalLimiter} from "./assistant.js";
 import {getAllPacks} from "../packs.js";
 import {throttleMiddleware} from "../middlewares/throttle.js";
+import {Config} from "../config.js";
 
 // Obtenir le chemin du répertoire courant de manière fiable avec ES Modules
 const __filename = fileURLToPath(import.meta.url);
@@ -147,7 +148,7 @@ export const jobDumpUserData = async () => {
 
         users.forEach((user) =>
         {
-            if( /^demo[0-9]{1,2}$/.test(user?.username))
+            if( isDemoUser(user) && Config.Get("useDemoAccounts"))
                 return;
             try {
                 dumpUserData(user).catch(e => {
@@ -383,7 +384,7 @@ export const dataTypes = {
         }
     },
     boolean: {
-        validate: (value) => typeof value === 'boolean',
+        validate: (value) => value === null || typeof value === 'boolean',
         anonymize: () => {
             return !!getRandom(0, 1);
         }
@@ -1459,7 +1460,7 @@ export async function onInit(defaultEngine) {
 
     engine.put('/api/model/:id', [middlewareAuthenticator, userInitiator, setTimeoutMiddleware(15000)], async (req, res) => {
 
-        if( !/^demo[0-9]{1,2}$/.test(req.me.username) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_EDIT_MODEL"], req.me)){
+        if( !(isDemoUser(req.me) && Config.Get("useDemoAccounts")) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_EDIT_MODEL"], req.me)){
             return res.status(403).json({success: false, error: i18n.t('api.permission.editModel', 'Cannot edit models from the API')})
         }
 
@@ -1698,7 +1699,7 @@ export async function onInit(defaultEngine) {
 
     engine.get('/api/models', [throttle, middlewareAuthenticator, userInitiator, middlewareLogger], async (req, res) => {
 
-        if( !/^demo[0-9]{1,2}$/.test(req.me.username) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_GET_MODELS"], req.me)){
+        if( !(isDemoUser(req.me) && Config.Get("useDemoAccounts")) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_GET_MODELS"], req.me)){
             return res.status(403).json({success: false, error: i18n.t('api.permission.getModels')})
         }
 
@@ -1726,7 +1727,7 @@ export async function onInit(defaultEngine) {
                 return res.status(400).json({error: "Le paramètre 'name' est requis."});
             }
 
-            if( !/^demo[0-9]{1,2}$/.test(req.me.username) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_GET_MODEL"], req.me) && !await hasPermission("API_GET_MODEL_"+modelName, req.me)){
+            if( !(isDemoUser(req.me) && Config.Get("useDemoAccounts")) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_GET_MODEL"], req.me) && !await hasPermission("API_GET_MODEL_"+modelName, req.me)){
                 return res.json({success: false, error: i18n.t('api.permission.getModel')})
             }
 
@@ -1738,7 +1739,7 @@ export async function onInit(defaultEngine) {
     });
     engine.post('/api/model', [throttle, middlewareAuthenticator, userInitiator, middlewareLogger, myFreePremiumAnonymousLimiter], async (req, res) => {
 
-        if( !/^demo[0-9]{1,2}$/.test(req.me.username) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_ADD_MODEL"], req.me) ){
+        if( !(isDemoUser(req.me) && Config.Get("useDemoAccounts")) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_ADD_MODEL"], req.me) ){
             return res.status(403).json({success: false, error: i18n.t('api.permission.addModel')})
         }
         try {
@@ -1810,7 +1811,7 @@ export async function onInit(defaultEngine) {
                 })));
             }
             const install = !!req.fields.install;
-            if( install && /^demo[0-9]{1,2}$/.test(req.me.username) ){
+            if( install && (isDemoUser(req.me) && Config.Get("useDemoAccounts")) ){
 
                 await datasCollection.deleteMany({ _user: req.me.username});
                 await modelsCollection.deleteMany({ _user: req.me.username});
@@ -1846,7 +1847,7 @@ export async function onInit(defaultEngine) {
             return res.status(400).json({error: "Le paramètre 'name' est requis."});
         }
 
-        if( !/^demo[0-9]{1,2}$/.test(req.me.username) && isLocalUser(req.me) && (
+        if( !(isDemoUser(req.me) && Config.Get("useDemoAccounts")) && isLocalUser(req.me) && (
             !await hasPermission(["API_ADMIN","API_DELETE_MODEL","API_DELETE_MODEL_"+modelName], req.me) ||
             await hasPermission(["API_DELETE_MODEL_NOT_"+modelName], req.me))){
             return res.status(403).json({success: false, error: i18n.t( "api.permission.deleteModel", { model: modelName})})
@@ -1910,7 +1911,7 @@ export async function onInit(defaultEngine) {
                 return res.status(404).json({ error: i18n.t('api.model.notFound', { model: modelId }) });
             }
 
-            if( !/^demo[0-9]{1,2}$/.test(req.me.username) && isLocalUser(req.me) && (
+            if( !(isDemoUser(req.me) && Config.Get("useDemoAccounts")) && isLocalUser(req.me) && (
                 !await hasPermission(["API_ADMIN", "API_EDIT_MODEL", "API_EDIT_MODEL_"+model.name], req.me) ||
                 await hasPermission(["API_EDIT_MODEL_NOT_"+model.name], req.me))){
                 return res.status(403).json({success: false, error: i18n.t('api.permission.editModel')})
@@ -2323,7 +2324,7 @@ export async function onInit(defaultEngine) {
 
 
     engine.post('/api/data/removeFromPack', [throttle, middlewareAuthenticator, userInitiator, myFreePremiumAnonymousLimiter], async (req, res) => {
-        if( !/^demo[0-9]{1,2}$/.test(req.me.username) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_CREATE_PACK"], req.me)){
+        if( !(isDemoUser(req.me) && Config.Get("useDemoAccounts")) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_CREATE_PACK"], req.me)){
             return res.status(403).json({success: false, error: i18n.t('api.permission.createPack')})
         }
         const { itemIds } = req.fields;
@@ -2459,7 +2460,7 @@ export async function onInit(defaultEngine) {
         const { packName, itemIds } = req.fields;
         const user = req.me;
 
-        if( !/^demo[0-9]{1,2}$/.test(req.me.username) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_CREATE_PACK"], req.me)){
+        if( !(isDemoUser(req.me) && Config.Get("useDemoAccounts")) && isLocalUser(req.me) && !await hasPermission(["API_ADMIN", "API_CREATE_PACK"], req.me)){
             return res.status(403).json({success: false, error: i18n.t('api.permission.createPack')})
         }
         // --- Validation ---
@@ -2591,14 +2592,18 @@ export async function onInit(defaultEngine) {
 }
 
 export const createModel = async (data) => {
-    return await modelsCollection.insertOne(data);
+    return await getCollection('models').insertOne(data);
+}
+
+export const deleteModels = async (filter) => {
+    return await getCollection('models').deleteMany(filter ? filter : {_user: { $exists: false }});
 }
 
 export const getModel = async (modelName, user) => {
     const modelInCache = modelsCache.get(user.username+"@@"+modelName);
     if(modelInCache)
         return modelInCache;
-    const model = await modelsCollection.findOne({name: modelName, $and: [{_user: {$exists: true}}, {$or: [{_user: user._user}, {_user: user.username}]}]});
+    const model = await getCollection('models').findOne({name: modelName, $and: [{_user: {$exists: true}}, {$or: [{_user: user._user}, {_user: user.username}]}]});
     if (!model) {
         throw new Error(i18n.t('api.model.notFound', {model: modelName}));
     }
@@ -2606,7 +2611,7 @@ export const getModel = async (modelName, user) => {
     return model;
 }
 export const getModels = async ()  => {
-    return await modelsCollection.find({'$or': [{_user: { $exists: false}}]}).toArray();
+    return await getCollection('models').find({'$or': [{_user: { $exists: false}}]}).toArray();
 }
 
 
@@ -2722,7 +2727,7 @@ export async function checkServerCapacity(incomingDataSize = 0) {
 export const insertData = async (modelName, data, files, user, triggerWorkflow = true, waitForWorkflow = true) => {
 
     // --- Vérification des permissions (inchangée) ---
-    if (!/^demo[0-9]{1,2}$/.test(user.username) && isLocalUser(user) && (
+    if (!(isDemoUser(user) && Config.Get("useDemoAccounts")) && isLocalUser(user) && (
         !await hasPermission(["API_ADMIN", "API_ADD_DATA", "API_ADD_DATA_" + modelName], user) ||
         await hasPermission(["API_ADD_DATA_NOT_" + modelName], user))) {
         // Renvoyer une structure d'erreur cohérente
@@ -3161,28 +3166,29 @@ async function applyFieldFilters(docToProcess, model) {
 /**
  * Valide la structure et le contenu du document selon le modèle
  */
-function validateModelData(doc, model) {
-    // 1. Vérification des champs obligatoires
-     model.fields.forEach(field =>{
-        const value = doc[field.name];
-        if (field.required) {
-            if (value === undefined && !('default' in field)) {
-                throw new Error(i18n.t('api.field.missingRequired', { field: field.name+" ("+model.name+")" }));
-            }
-            if (value === '' || value === null) {
-                throw new Error(i18n.t('api.field.requiredCannotBeEmpty', { field: field.name }));
+function validateModelData(doc, model, isPatch = false) {
+    if (!isPatch) {
+        model.fields.forEach(field => {
+            const value = doc[field.name];
+            if (field.required) {
+                if (value === undefined && !('default' in field)) {
+                    throw new Error(i18n.t('api.field.missingRequired', { field: field.name + " (" + model.name + ")" }));
+                }
+                if (value === '' || value === null) {
+                    throw new Error(i18n.t('api.field.requiredCannotBeEmpty', { field: field.name }));
+                }
             }
-        }
-    });
+        });
+    }
 
-    // 2. Validation des types de champs
+    // 2. Validation des types de champs (toujours exécutée pour les champs fournis)
     for (const [fieldName, value] of Object.entries(doc)) {
         const fieldDef = model.fields.find(f => f.name === fieldName);
         if (!fieldDef) continue; // On ignore les champs supplémentaires
 
         const validator = dataTypes[fieldDef.type]?.validate;
         if (validator && !validator(value, fieldDef)) {
-            throw new Error(i18n.t('api.field.validationFailed', { field: fieldName, value}));
+            throw new Error(i18n.t('api.field.validationFailed', { field: fieldName, value }));
         }
     }
 }
@@ -3358,9 +3364,11 @@ export const editData = async (modelName, filter, data, files, user, triggerWork
     return await internalEditOrPatchData(modelName, filter, data, files, user, false, triggerWorkflow, waitForWorkflow);
 };
 
+// Dans src/modules/data.js
+
 const internalEditOrPatchData = async (modelName, filter, data, files, user, isPatch, triggerWorkflow = true, waitForWorkflow = false) => {
     try {
-        // Vérification des permissions
+        // 1. Vérification des permissions
         if (user.username !== 'demo' && isLocalUser(user) && (
             !await hasPermission(["API_ADMIN", "API_EDIT_DATA", "API_EDIT_DATA_" + modelName], user) ||
             await hasPermission(["API_EDIT_DATA_NOT_" + modelName], user))) {
@@ -3373,22 +3381,20 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             throw new Error(i18n.t("api.model.notFound", {model: modelName}));
         }
 
-        // Récupération des documents existants
+        // 2. Récupération des documents existants et de leur hash original
         const existingDocs = (await searchData({user, query: {model: modelName, filter}}))?.data;
         if (!existingDocs || existingDocs.length === 0) {
             return {success: false, error: i18n.t("api.data.notFound")};
         }
-
         const ids = existingDocs.map(d => new ObjectId(d._id));
+        const originalHash = existingDocs[0]._hash; // Sauvegarde du hash avant modification
 
-        // Préparation des données de mise à jour
+        // 3. Préparation des données de mise à jour (inchangé)
         const updateData = {...data};
         delete updateData._model;
         delete updateData._user;
 
-        const dataToValidateAndHash = { ...existingDocs[0], ...updateData };
-
-        // Traitement des fichiers
+        // Traitement des fichiers (inchangé)
         const fileFields = model.fields.filter(f => f.type === 'file' || (f.type === 'array' && f.itemsType === 'file'));
         for (const field of fileFields) {
             if (files?.[field.name+'[0]']) {
@@ -3402,12 +3408,15 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        // Validation complète si ce n'est pas un patch
+        // 4. Validation adaptée pour patch ou edit (inchangé)
         if (!isPatch) {
-            validateModelData(updateData, model);
+            const dataToValidate = { ...existingDocs[0], ...updateData };
+            validateModelData(dataToValidate, model, false);
+        } else {
+            validateModelData(updateData, model, true);
         }
 
-        // Vérification des champs uniques
+        // 5. Vérification des champs uniques (inchangé)
         const uniqueFields = model.fields.filter(f => f.unique);
         for (const field of uniqueFields) {
             if (updateData[field.name] !== undefined) {
@@ -3415,31 +3424,27 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
                     _user: user._user || user.username,
                     _model: modelName,
                     [field.name]: updateData[field.name],
-                    _id: {$nin: ids} // Exclure les documents actuels
+                    _id: {$nin: ids}
                 });
-
                 if (existing) {
-                    throw new Error(i18n.t("api.data.duplicateValue", {
-                        field: field.name,
-                        value: updateData[field.name]
-                    }));
+                    throw new Error(i18n.t("api.data.duplicateValue", { field: field.name, value: updateData[field.name] }));
                 }
             }
         }
+
+        // 6. Traitement des relations (inchangé)
         const relationFields = model.fields.filter(f => f.type === 'relation');
         for (const field of relationFields) {
             if (updateData[field.name] !== undefined) {
                 const relationValue = updateData[field.name];
                 if (relationValue !== null && typeof relationValue === 'object') {
-                    // Ajouter l'option preserveIds: true pour conserver les IDs
                     const insertedIds = await pushDataUnsecure(relationValue, field.relation, user, { preserveIds: true });
                     updateData[field.name] = field.multiple ? insertedIds || [] : insertedIds?.[0] || null;
                 }
             }
         }
 
-
-        // Gestion des mots de passe et autres filtres
+        // 7. Application des filtres de champ (ex: hashage de mot de passe) (inchangé)
         for (const field of model.fields) {
             if (updateData[field.name] !== undefined && dataTypes[field.type]?.filter) {
                 updateData[field.name] = await dataTypes[field.type].filter(
@@ -3449,23 +3454,31 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        const finalHash = getFieldValueHash(model, dataToValidateAndHash);
+        // 8. Calcul du nouveau hash et préparation des données finales
+        const finalStateForHash = { ...existingDocs[0], ...updateData };
+        const newHash = getFieldValueHash(model, finalStateForHash);
 
-        // On ne met à jour que les champs fournis + le nouveau hash
         const finalDataForSet = {
             ...updateData,
-            _hash: finalHash
+            _hash: newHash
         };
 
-        const hashCheck = await checkHash(user, model, finalHash, existingDocs[0]._id.toString());
-        if (hashCheck) {
-            throw new Error(i18n.t("api.data.notUniqueData"));
+        // 9. *** CORRECTION LOGIQUE ***
+        // On ne vérifie l'unicité que si le hash a réellement changé.
+        if (newHash !== originalHash) {
+            const hashCheck = await checkHash(user, model, newHash, existingDocs[0]._id.toString());
+            if (hashCheck) {
+                // Le nouvel état du document créerait un doublon.
+                throw new Error(i18n.t("api.data.notUniqueData"));
+            }
         }
 
+        // 10. Exécution de la mise à jour (inchangé)
         const bulkOps = [{ updateMany: { filter: {_id: {$in: ids}}, update: {$set: finalDataForSet} } }];
         const bulkResult = await collection.bulkWrite(bulkOps);
         const modifiedCount = bulkResult.modifiedCount || 0;
 
+        // 11. Tâches post-mise à jour (schedules, workflows) (inchangé)
         if (["workflowTrigger", "alert"].includes(modelName)) {
             await handleScheduledJobs(modelName, existingDocs, collection, finalDataForSet);
         }
@@ -4231,8 +4244,10 @@ export const searchData = async ({user, query}) => {
         pipelines.push({$project: {_user: 0}});
         pipelines.push({$project: {_model: 0}});
     }
-    console.log(util.inspect(pipelines, false, 29, true))
 
+    console.log(util.inspect(pipelines, false, 29, true));
+
+    // 4. Exécuter la pipeline
     const ts = parseInt(timeout, 10)/2.0 || searchRequestTimeout;
     const count = await collection.aggregate([...pipelines, { $count: "count" }]).maxTimeMS(ts).toArray();
     let prom = collection.aggregate(pipelines).maxTimeMS(ts);
@@ -4249,7 +4264,7 @@ export const searchData = async ({user, query}) => {
 
 export const importData = async(options, files, user) => {
 
-    if( !/^demo[0-9]{1,2}$/.test(user.username) && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_IMPORT_DATA"], user)){
+    if( !(isDemoUser(user) && Config.Get("useDemoAccounts")) && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_IMPORT_DATA"], user)){
         return ({ success: false, error: "API_IMPORT_DATA permission needed." });
     }
 
@@ -4602,7 +4617,7 @@ export const exportData= async (options, user) =>{
             // Example using hasPermission:
             // if (user.username !== 'demo' && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_SEARCH_DATA", "API_SEARCH_DATA_"+modelName], user)) {
             // Example using checkPermission (if it exists and works similarly):
-            if (isLocalUser(user) && /^demo[0-9]{1,2}$/.test(user?.username) && !(await hasPermission('API_EXPORT_DATA', user))) { // Adapt this line based on your actual permission function
+            if (isLocalUser(user) && !(isDemoUser(user) && Config.Get("useDemoAccounts")) && !(await hasPermission('API_EXPORT_DATA', user))) { // Adapt this line based on your actual permission function
                 console.warn(`User ${userId} lacks permission to search/export model ${modelName}`);
                 errors.push(i18n.t('api.permission.searchData', 'Cannot search data from the API') + ` (${modelName})`);
                 continue; // Skip this model
@@ -5384,6 +5399,8 @@ export async function installPack(logger, packId, user, lang) {
         if (documents.length === 0) continue;
 
         const docsToInsert = [];
+        console.log(modelName, user);
+
         const modelDefForHash = await getModel(modelName, user);
 
         for (const docSource of documents) {

package/src/modules/mongodb.js

@@ -2,7 +2,7 @@
 import process from "process";
 import {MongoClient as InternalMongoClient} from "mongodb";
 import {Logger} from "../gameObject.js";
-import {MongoDatabase} from "../engine.js";
+import {MongoClient, MongoDatabase} from "../engine.js";
 import * as tls from "node:tls";
 import fs from "node:fs";
 

package/src/modules/workflow.js

@@ -365,45 +365,40 @@ async function handleCreateDataAction(actionDef, contextData, user, dbCollection
 
     try {
         // 2. Substitute Variables in the data template
-        let substitutedDataString;
         let dataObject;
 
-        // dataToCreate might be a string (JSON) or already an object from the model definition
         if (typeof dataToCreate === 'string') {
-            substitutedDataString = await substituteVariables(dataToCreate, contextData, user);
-            console.log({substitutedDataString});
+            const substitutedDataString = await substituteVariables(dataToCreate, contextData, user);
+            try {
+                // CORRECTION : Utiliser la bonne variable (substitutedDataString)
+                dataObject = JSON.parse(substitutedDataString);
+            } catch (parseError) {
+                const msg = `Failed to parse substituted JSON string: ${substitutedDataString}. Error: ${parseError.message}`;
+                logger.error(`[handleCreateDataAction] ${msg}`);
+                return { success: false, message: msg };
+            }
         } else if (typeof dataToCreate === 'object') {
-            // If it's an object, substitute within its values
-            const substitutedObject = await substituteVariables(dataToCreate, contextData, user);
-            // We still need to stringify and parse if it was originally intended as JSON string
-            // Or assume it's meant to be used directly if it came as an object
-            // Let's assume direct use for now if it's an object in the definition
-            dataObject = substitutedObject;
-
-            console.log({substitutedObject});
+            // CORRECTION : Assigner le résultat de la substitution à dataObject.
+            // On passe une copie pour ne pas muter le template original.
+            dataObject = await substituteVariables(JSON.parse(JSON.stringify(dataToCreate)), contextData, user);
         } else {
-            const msg = `[handleCreateDataAction] Action ${actionDef.name} (${actionDef._id}): 'dataToCreate' has an invalid type (${typeof dataToCreate}). Expected string (JSON) or object.`;
+            const msg = `[handleCreateDataAction] 'dataToCreate' has an invalid type (${typeof dataToCreate}). Expected string (JSON) or object.`;
             logger.error(msg);
             return { success: false, message: msg };
         }
 
+        // Log pour débogage
+        logger.debug('Final data object after substitution:', dataObject);
 
-        // 3. Parse the substituted data if it was a string
-        if (substitutedDataString) {
-            try {
-                dataObject = JSON.parse(substitutedDataString);
-                if (typeof dataObject !== 'object' || dataObject === null) {
-                    throw new Error("Parsed data is not a valid object.");
-                }
-            } catch (parseError) {
-                const msg = `[handleCreateDataAction] Action ${actionDef.name} (${actionDef._id}): Failed to parse substituted 'dataToCreate' JSON. Error: ${parseError.message}. Substituted string: ${substitutedDataString}`;
-                logger.error(msg);
-                return { success: false, message: msg };
-            }
-        }
+        // 3. Appeler insertData avec l'objet correctement substitué
+        const result = await insertData(targetModel, dataObject, [], user, true, true); // On attend la fin du workflow déclenché par cette création
 
-        const ids = await insertData(targetModel, dataObject, [], user, false);
-        return { success: true, insertedIds: ids };
+        if (result.success) {
+            return { success: true, insertedIds: result.insertedIds };
+        } else {
+            // Propage l'erreur venant de insertData
+            return { success: false, message: result.error || "Insertion failed." };
+        }
 
     } catch (error) {
         const msg = `[handleCreateDataAction] Action ${actionDef.name} (${actionDef._id}): Unexpected error during creation for model '${targetModel}'. Error: ${error.message}`;
@@ -723,9 +718,124 @@ function getNestedValue(obj, path) {
     // Retourne la valeur finale trouvée
     return current;
 }
+
+/**
+ * Résout un chemin de variable complexe (ex: "triggerData.order.customer.contact.email")
+ * en construisant un pipeline d'agrégation dynamique pour tout récupérer en une seule requête.
+ *
+ * @param {string} pathString - Le chemin de la variable, ex: "triggerData.order.customer.contact.email".
+ * @param {object} initialContext - L'objet de départ (le triggerData).
+ * @param {object} user - L'objet utilisateur pour les requêtes DB.
+ * @returns {Promise<any>} La valeur résolue.
+ */
+async function resolvePathValue(pathString, initialContext, user) {
+    const pathParts = pathString.split('.');
+    const rootObjectKey = pathParts.shift(); // ex: "triggerData"
+
+    // Si le chemin ne commence pas par triggerData ou context, essayer de résoudre directement
+    if (rootObjectKey !== 'triggerData' && rootObjectKey !== 'context') {
+        let current = initialContext;
+        for (const part of [rootObjectKey, ...pathParts]) {
+            if (current === null || typeof current === 'undefined') return undefined;
+            current = current[part];
+        }
+        return current;
+    }
+
+    // Vérifier si c'est un chemin simple qui peut être résolu sans aggregation
+    if (pathParts.length === 1) {
+        return initialContext[pathParts[0]];
+    }
+
+    let currentModelName = initialContext._model;
+    let currentDocId = new ObjectId(initialContext._id);
+    const collection = getCollectionForUser(user);
+
+    // Construire le pipeline d'agrégation
+    const pipeline = [
+        { $match: { _id: currentDocId } }
+    ];
+
+    // Itérer sur chaque segment du chemin pour construire les lookups
+    for (let i = 0; i < pathParts.length; i++) {
+        const segment = pathParts[i];
+
+        // Si c'est le dernier segment, on n'a pas besoin de faire un lookup
+        if (i === pathParts.length - 1) break;
+
+        const modelDef = await getModel(currentModelName, user);
+        const fieldDef = modelDef.fields.find(f => f.name === segment);
+
+        if (!fieldDef || fieldDef.type !== 'relation') {
+            // Si ce n'est pas une relation, on ne peut pas continuer le chemin
+            return undefined;
+        }
+
+        const nextModelName = fieldDef.relation;
+        const asField = `__resolved_${segment}`;
+
+        pipeline.push({
+            $lookup: {
+                from: collection.collectionName,
+                let: { relationId: `$${segment}` },
+                pipeline: [
+                    {
+                        $match: {
+                            $expr: {
+                                $eq: ["$_id", {
+                                    $cond: {
+                                        if: { $eq: [{ $type: "$$relationId" }, "string"] },
+                                        then: { $toObjectId: "$$relationId" },
+                                        else: "$$relationId"
+                                    }
+                                }]
+                            }
+                        }
+                    }
+                ],
+                as: asField
+            }
+        });
+
+        pipeline.push({
+            $unwind: {
+                path: `$${asField}`,
+                preserveNullAndEmptyArrays: true
+            }
+        });
+
+        pipeline.push({
+            $addFields: {
+                [segment]: `$${asField}`
+            }
+        });
+
+        pipeline.push({ $project: { [asField]: 0 } });
+
+        currentModelName = nextModelName;
+    }
+
+    const results = await collection.aggregate(pipeline).toArray();
+
+    if (results.length === 0) {
+        return undefined;
+    }
+
+    // Extraire la valeur finale
+    let finalValue = results[0];
+    for (const part of pathParts) {
+        if (finalValue === null || typeof finalValue === 'undefined') {
+            return undefined;
+        }
+        finalValue = finalValue[part];
+    }
+
+    return finalValue;
+}
+
 /**
  * Remplace les placeholders dans un template (string, object, array) par des valeurs du contextData.
- * Mise à jour pour une meilleure gestion des types et des placeholders introuvables.
+ * Version améliorée avec support des chemins complexes via resolvePathValue.
  */
 export async function substituteVariables(template, contextData, user) {
     // 1. Retourner les types non substituables tels quels
@@ -759,54 +869,76 @@ export async function substituteVariables(template, contextData, user) {
     // `contextToSearch` contient toutes les données disponibles à sa racine
     const contextToSearch = { ...contextData, env: userEnv };
 
-    // 5. Logique de résolution de valeur unifiée
-    const findValue = (key) => {
-        let value;
+    // 5. Logique de résolution de valeur améliorée avec resolvePathValue
+    const findValue = async (key) => {
         let path = key.trim();
-
-        // Gérer les raccourcis : {triggerData.field} -> {context.triggerData.field}
-        if (path.startsWith('triggerData.')) {
-            path = 'context.' + path;
+        if (path.endsWith('._id')) {
+            const basePath = path.slice(0, -4);
+            const value = await findValue(basePath);
+            return value?._id?.toString(); // Convertit l'ObjectId en string
         }
-        // Note : Pas de gestion spéciale pour {env.*} car `env` est déjà à la racine de contextToSearch.
 
         // Gérer les valeurs dynamiques spéciales
         if (path === 'now') {
-            value = new Date().toISOString();
+            return new Date().toISOString();
         } else if (path === 'randomUUID') {
-            // Suppose que 'crypto' est disponible dans le scope (ex: Node.js >= 19 ou avec import 'node:crypto')
-            value = crypto.randomUUID();
-        } else {
-            // Chercher le chemin dans l'objet de contexte entier
-            value = getNestedValue(contextToSearch, path);
+            return crypto.randomUUID();
         }
-        return value;
+
+        // Détecter si le chemin est complexe (contient plus d'un point)
+        if (path.split('.').length > 1) {
+            try {
+                // Essayer de résoudre le chemin avec resolvePathValue
+                const [root, ...rest] = path.split('.');
+                // On vérifie si la racine du chemin (ex: 'triggerData') existe dans notre contexte
+                if (contextToSearch[root]) {
+                    const resolvedValue = await resolvePathValue(
+                        rest.join('.'),
+                        contextToSearch[root], // On passe le bon objet de départ (ex: l'objet triggerData)
+                        user
+                    );
+                    if (resolvedValue !== undefined) {
+                        return resolvedValue;
+                    }
+                }
+            } catch (error) {
+                console.warn(`Erreur lors de la résolution du chemin "${path}":`, error.message);
+                // On continue avec la méthode normale si la résolution échoue
+            }
+        }
+
+        // Fallback: chercher le chemin dans l'objet de contexte normal
+        return getNestedValue(contextToSearch, path);
     };
 
     // CAS A : La chaîne est un unique placeholder (ex: "{context.triggerData.product.price}")
-    // Ceci préserve le type de donnée original (nombre, booléen, objet, etc.).
     const singlePlaceholderMatch = template.match(/^\{([^}]+)\}$/);
     if (singlePlaceholderMatch) {
         const key = singlePlaceholderMatch[1];
-        const value = findValue(key);
-        // Si une valeur est trouvée, la retourner directement. Sinon, retourner le template original.
+        const value = await findValue(key);
         return value !== undefined ? value : template;
     }
 
-    // CAS B : La chaîne est complexe (ex: "Produit: {context.triggerData.product.name}!")
-    // Le résultat sera toujours une chaîne de caractères.
+    // CAS B : La chaîne contient plusieurs placeholders ou mix texte/variables
     const placeholderRegex = /\{([^}]+)\}/g;
-    return template.replace(placeholderRegex, (match, key) => {
-        const value = findValue(key);
+    const placeholders = [...template.matchAll(placeholderRegex)];
 
-        if (value !== undefined) {
-            if (value === null) return 'null'; // Convertir explicitement null en chaîne 'null'
-            if (typeof value === 'object') return JSON.stringify(value); // Convertir les objets/tableaux en JSON
-            return String(value); // S'assurer que les autres types sont convertis en chaîne
-        }
+    // Si aucun placeholder trouvé, retourner la chaîne telle quelle
+    if (placeholders.length === 0) {
+        return template;
+    }
 
-        return match; // Placeholder non trouvé, le laisser tel quel
-    });
+    // Remplacer chaque placeholder de manière asynchrone
+    let result = template;
+    for (const [match, key] of placeholders) {
+        const value = await findValue(key);
+        const replacement = value !== undefined
+            ? (value === null ? 'null' : typeof value === 'object' ? JSON.stringify(value) : String(value))
+            : match;
+        result = result.replace(match, replacement);
+    }
+
+    return result;
 }
 
 /**

package/src/packs.js

@@ -242,20 +242,17 @@ export const getAllPacks = async () => {
                     },{
                         "name": "Data purging",
                         "startStep": { "$link": { "name": "Purge execution", "_model": "workflowStep" } }
+                    },{
+                        "name": "Shipment Notification",
+                        "description": "Notifies the customer when their order has been shipped.",
+                        "startStep": { "$link": { "name": "Send Shipment Email Step", "_model": "workflowStep" } }
                     }],
                     "workflowAction": [
-                        { "name": "Update order status to 'processing'", "type": "UpdateData", "targetModel": "order", "targetSelector": { "_id": "{triggerData._id}" }, "fieldsToUpdate": { "status": "processing" } },
+                        { "name": "Update order status to 'processing'", "type": "UpdateData", "targetModel": "order", "targetSelector": { "_id": { $toObjectId: "{triggerData._id}" }}, "fieldsToUpdate": { "status": "processing" } },
                         { "name": "Create Shipment Record", "type": "CreateData",
                             "targetModel": "shipment",
                             "dataToCreate": { "order": "{triggerData._id}", "status": "preparing" } },
-                        { "name": "Update order status to 'shipped'", "type": "UpdateData", "targetModel": "order", "targetSelector": { "_id": "{triggerData._id}" }, "fieldsToUpdate": { "status": "shipped" } },
-                        {
-                            "name": "Send Shipping Confirmation",
-                            "type": "SendEmail",
-                            "emailRecipients": ["{triggerData.customer.email}"],
-                            "emailSubject": "Your order #{triggerData.orderId} has been shipped!",
-                            "emailContent": "Hello {triggerData.customer.firstName},<br><br>Good news! Your order is on its way. You can track it using this number: {context.CreateShipmentRecord.insertedIds[0]}.<br><br>Thank you for your purchase!"
-                        },
+                        { "name": "Update order status to 'shipped'", "type": "UpdateData", "targetModel": "order", "targetSelector": { "_id": { $toObjectId: "{triggerData._id}" }}, "fieldsToUpdate": { "status": "shipped" } },
                         {
                             name: 'Delete queries older than 30 days',
                             type: 'DeleteData',
@@ -263,6 +260,14 @@ export const getAllPacks = async () => {
                             targetSelector: {
                                 "$lt": ["$timestamp", {"$subtract": ["$$NOW", 1000*3600*24*365*5] } ]
                             }
+                        },
+                        {
+                            "name": "Send Shipping Notification Email",
+                            "type": "SendEmail",
+                            // C'est ici que la magie opère !
+                            "emailRecipients": ["{triggerData.order.customer.contact.email}"],
+                            "emailSubject": "Your order #{triggerData.order.orderId} has been shipped!",
+                            "emailContent": "Hello {triggerData.order.customer.contact.firstName},<br><br>Good news! Your order #{triggerData.order.orderId} is on its way. You can track it using this number: <strong>{triggerData.trackingNumber}</strong>.<br><br>Thank you for your purchase!"
                         }
                     ],
                     "workflowStep": [
@@ -278,6 +283,12 @@ export const getAllPacks = async () => {
                             "actions": { "$link": { "name": "Create Shipment Record", "_model": "workflowAction" } },
                             "onSuccessStep": { "$link": { "name": "Ship Order", "_model": "workflowStep" } },
                         },
+                        {
+                            "name": "Send Shipment Email Step",
+                            "workflow": { "$link": { "name": "Shipment Notification", "_model": "workflow" } },
+                            "actions": { "$link": { "name": "Send Shipping Notification Email", "_model": "workflowAction" } },
+                            "isTerminal": true
+                        },
                         {
                             "name": "Ship Order",
                             "workflow": { "$link": { "name": "Order Fulfillment", "_model": "workflow" }},
@@ -300,7 +311,12 @@ export const getAllPacks = async () => {
                         }
                     ],
                     "workflowTrigger": [{
-                        "name": "New order created", "workflow": { "$link": { "name": "Order Fulfillment", "_model": "workflow" } }, "type": "manual", "onEvent": "DataAdded", "dataFilter":{}, "targetModel": "order", "isActive": true
+                        "name": "On New Shipment Created",
+                        "workflow": { "$link": { "name": "Shipment Notification", "_model": "workflow" } },
+                        "type": "manual", // Déclenché par un événement
+                        "onEvent": "DataAdded",
+                        "targetModel": "shipment",
+                        "isActive": true
                     },{
                         name: 'Daily data purge',
                         type: 'scheduled',