data-primals-engine 1.6.3 → 1.6.5

package/src/modules/swagger.js

@@ -10,9 +10,29 @@ let engine, logger;
 export async function onInit(defaultEngine) {
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
-
-    const swaggerDocument = YAML.parse(fs.readFileSync(process.cwd() + '/swagger-en.yml', 'utf8'));
-
-    engine.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));
-
+    
+    const swaggerDocs = {
+        en: YAML.parse(fs.readFileSync(process.cwd() + '/swagger-en.yml', 'utf8')),
+        fr: YAML.parse(fs.readFileSync(process.cwd() + '/swagger-fr.yml', 'utf8'))
+    };
+    
+    // Sers les assets de swagger-ui
+    engine.use('/api-docs', swaggerUi.serve);
+    
+    // Route pour la langue par défaut (ex: /api-docs)
+    engine.get('/api-docs', (req, res) => {
+        return swaggerUi.setup(swaggerDocs['en'])(req, res);
+    });
+    
+    // Route pour une langue spécifique (ex: /api-docs/fr)
+    engine.get('/api-docs/:lang', (req, res) => {
+        const lang = req.params.lang;
+    
+        // Si la langue demandée n'existe pas, on redirige vers la version anglaise.
+        if (!swaggerDocs[lang]) {
+            return res.redirect('/api-docs/en');
+        }
+    
+        return swaggerUi.setup(swaggerDocs[lang])(req, res);
+    });
 };

package/src/modules/user.js

@@ -15,8 +15,10 @@ import rateLimit from "express-rate-limit";
 import ivm from "isolated-vm";
 import {emailDefaultConfig} from "../constants.js";
 import {safeAssignObject} from "../core.js";
-import {substituteVariables} from "../filter.js";
+import {substituteVariables} from "./workflow.js";
+import NodeCache from "node-cache";
 import {Config} from "../config.js";
+import { Event } from '../events.js';
 
 export const userInitiator = async (req, res, next) => {
 
@@ -99,7 +101,28 @@ let logger,engine;
 export async function onInit(defaultEngine) {
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
+
+    const invalidatePermissionsCache = (engine, {modelName, insertedDocs, user}) => {
+        const modelsToWatch = ['role', 'permission', 'userPermission'];
+
+        // Le payload contient le nom du modèle qui a été modifié.
+        if (modelName && modelsToWatch.includes(modelName)) {
+            logger.info(`[Permissions] Invalidating permissions cache due to change in '${modelName}'.`);
+            permissionsCache.flushAll();
+        }
+    };
+
+    // On attache notre fonction d'invalidation aux événements système.
+    Event.Listen("OnDataAdded", invalidatePermissionsCache, "event", "system");
+    Event.Listen("OnDataEdited", invalidatePermissionsCache, "event", "system");
+    Event.Listen("OnDataDeleted", invalidatePermissionsCache, "event", "system");
 }
+/**
+ * Cache pour les permissions des utilisateurs.
+ * TTL de 10 minutes, vérification toutes les 2 minutes.
+ */
+const permissionsCache = new NodeCache({ stdTTL: 600, checkperiod: 120, useClones: false });
+
 /**
  * Calcule et retourne l'ensemble des permissions actives pour un utilisateur.
  * Cette fonction interne est la pierre angulaire de la nouvelle logique de permission.
@@ -110,6 +133,14 @@ export async function onInit(defaultEngine) {
  * @private
  */
 export async function getUserActivePermissions(user, env = null) {
+    // Clé de cache unique pour l'utilisateur et l'environnement
+    const cacheKey = `${user._user || user.username}:${user._id.toString()}:${env || 'global'}`;
+    const cachedPermissions = permissionsCache.get(cacheKey);
+    if (cachedPermissions) {
+        logger.debug(`[Permissions] Cache hit for user ${user.username}`);
+        return cachedPermissions;
+    }
+    logger.debug(`[Permissions] Cache miss for user ${user.username}. Calculating permissions...`);
     const datasCollection = await getCollectionForUser(user);
     const now = new Date();
     const activePermissions = new Map();
@@ -117,88 +148,87 @@ export async function getUserActivePermissions(user, env = null) {
     // --- ÉTAPE 1: Récupérer les permissions de base des rôles ---
     if (user.roles && user.roles.length > 0) {
         const roleIds = user.roles.map(id => new ObjectId(id));
- 
-        const rolePermissions = await datasCollection.aggregate([
-            { $match: { _id: { $in: roleIds }, _model: "role", _user: user.username } },
-            { $unwind: "$permissions" },
-            {
-                $lookup: {
-                    from: datasCollection.collectionName, // Utiliser la même collection
-                    let: { permissionIdStr: "$permissions" }, // La permission est un string
-                    pipeline: [
-                        { $match: {
-                            $expr: { $eq: [ { $toString: "$_id" }, "$$permissionIdStr" ] }
-                        }}
-                    ],
-                    as: "permissionDoc"
-                }
-            },
-            { $unwind: "$permissionDoc" },
-            { $project: { name: "$permissionDoc.name", filter: "$permissionDoc.filter" } }
-        ]).toArray();
 
-        rolePermissions.forEach(p => p.name && activePermissions.set(p.name, p.filter ?? null));
+        // Étape 1: Récupérer tous les IDs de permission des rôles de l'utilisateur.
+        const roles = await datasCollection.find(
+            { _id: { $in: roleIds }, _model: "role", _user: user._user || user.username },
+            { projection: { permissions: 1, _user: 1 } }
+        ).toArray();
+
+        // Aplatir tous les tableaux de permissions en un seul et supprimer les doublons.
+        const permissionIdStrings = [...new Set(roles.flatMap(role => role.permissions || []))];
+        const permissionObjectIds = permissionIdStrings.map(id => new ObjectId(id));
+
+        // Étape 2: Récupérer tous les documents de permission correspondants en une seule requête.
+        const rolePermissions = await datasCollection.find(
+            { _id: { $in: permissionObjectIds }, _model: "permission", _user: user._user || user.username },
+            { projection: { name: 1, filter: 1 } }
+        ).toArray();
+
+        rolePermissions.forEach(p => {
+            if (p.name) {
+                // On stocke l'objet permission complet pour un accès ultérieur
+                activePermissions.set(p.name, { filter: p.filter ?? null, details: p });
+            }
+        });
     }
 
+    // --- NOUVELLE ÉTAPE : Pré-charger les détails de toutes les permissions d'exception ---
+    // Cela garantit que nous avons les noms de permission même pour les révocations.
+    const exceptionPermissionIds = (await datasCollection.distinct("permission", {
+        _model: "userPermission",
+        user: user._id.toString(),
+        _user: user._user || user.username
+    })).map(id => new ObjectId(id));
+
+    const exceptionPermsDetails = await datasCollection.find(
+        { _id: { $in: exceptionPermissionIds }, _model: "permission" },
+        { projection: { name: 1, filter: 1 } }
+    ).toArray();
+
+    const allPermDetailsMap = new Map(exceptionPermsDetails.map(p => [p._id.toString(), p]));
+
     // --- ÉTAPE 2: Appliquer les exceptions de permission ---
-    const exceptions = await datasCollection.aggregate([
-        {
-            $match: { // Filtre de base pour les exceptions de l'utilisateur
-                _model: "userPermission",
-                user: user._id.toString(),
-                $and: [ // Filtre sur l'environnement et l'expiration
-                    {
-                        $or: [ // La permission est soit globale, soit spécifique à l'environnement demandé
-                            { env: { $exists: false } },
-                            { env: env }
-                        ]
-                    },
-                    { $or: [{ expiresAt: { $exists: false } }, { expiresAt: { $gt: now } }] }
-                ]
-            }
-        },
-        {
-            $lookup: {
-                from: datasCollection.collectionName,
-                let: { permissionId: "$permission" },
-                pipeline: [
-                    {
-                        $match: {
-                            $expr: { $eq: [ { $toString: "$_id" }, "$$permissionId" ] }
-                        }
-                    },
-                    { $project: { name: 1, filter: 1 } }
-                ],
-                as: 'permissionDoc'
-            }
-        },
-        { $unwind: '$permissionDoc' },
-        {
-            $project: { // On sélectionne les champs dont on a besoin
-                isGranted: 1,
-                filter: 1, // On ajoute le filtre de l'exception
-                permissionDoc: 1
+    const exceptionsQuery = {
+        _model: "userPermission",
+        user: user._id.toString(),
+        _user: user._user || user.username,
+        $and: [
+            { $or: [{ expiresAt: { $exists: false } }, { expiresAt: { $gt: now } }] },
+            { $or: [{ env: { $exists: false } }, { env: env }] }
+        ]
+    };
+
+    const exceptions = await datasCollection.find(exceptionsQuery, {
+        projection: { permission: 1, isGranted: 1, filter: 1 } // Le filtre sur l'exception
+    }).toArray();
+
+    if (exceptions.length > 0) {
+        for (const exception of exceptions) {
+            // Utiliser la map pré-chargée qui contient toutes les permissions d'exception
+            const permDetails = allPermDetailsMap.get(exception.permission);
+            if (!permDetails?.name) continue;
+
+            if (exception.isGranted) {
+                // Priorité 1: Le filtre défini sur l'exception elle-même.
+                // Priorité 2: Le filtre défini sur la permission de base.
+                const finalFilter = exception.filter ?? permDetails.filter ?? null;
+                // On met à jour l'entrée existante ou on en crée une nouvelle
+                activePermissions.set(permDetails.name, { filter: finalFilter, details: permDetails });
+            } else {
+                activePermissions.delete(permDetails.name);
             }
         }
-    ]).toArray();
-
-    // Appliquer les exceptions
-    for (const exception of exceptions) {
-        const permissionName = exception.permissionDoc?.name;
-        if (!permissionName) continue;
-
-        if (exception.isGranted) {
-            // Priorité 1: Le filtre défini sur l'exception elle-même.
-            // Priorité 2: Le filtre défini sur la permission de base.
-            // Priorité 3: null s'il n'y a aucun filtre.
-            const finalFilter = exception.filter ?? exception.permissionDoc.filter ?? null;
-            activePermissions.set(permissionName, finalFilter);
-        } else {
-            activePermissions.delete(permissionName);
-        }
     }
 
-    return activePermissions;
+    // Mettre le résultat en cache avant de le retourner
+    // On ne stocke que le nom et le filtre, pas l'objet 'details' complet
+    const finalPermissionsToCache = new Map();
+    for (const [name, permData] of activePermissions.entries()) {
+        finalPermissionsToCache.set(name, permData.filter);
+    }
+    permissionsCache.set(cacheKey, finalPermissionsToCache);
+    return finalPermissionsToCache;
 }
 
 /**
@@ -221,15 +251,15 @@ export async function hasPermission(permissionNames, user, env = null, req = nul
     }
 
     try {
+        // 1. Obtenir l'ensemble final et à jour des permissions de l'utilisateur
+        const activePermissions = await getUserActivePermissions(user, env);
+
         const requiredPermissions = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
         // Si aucune permission n'est requise, on autorise
         if (requiredPermissions.length === 0) {
             return true;
         }
 
-        // 1. Obtenir l'ensemble final et à jour des permissions de l'utilisateur
-        const activePermissions = await getUserActivePermissions(user, env);
-
         // 2. Chercher la première permission correspondante
         for (const pName of requiredPermissions) {
             if (activePermissions.has(pName)) {

package/src/modules/workflow.js

@@ -18,7 +18,144 @@ import {getEnv, getSmtpConfig} from "./user.js";
 import { providers } from "./assistant/constants.js";
 import { getAIProvider } from "./assistant/providers.js";
 import {Config} from "../config.js";
-import {substituteVariables} from "../filter.js";
+import {safeAssignObject} from "../core.js";
+
+/**
+ * Récupère une valeur imbriquée dans un objet (ex: 'user.address.city').
+ */
+const getNestedValue = (obj, path) => {
+    if (!path || !obj) return undefined;
+    return path.split('.').reduce((acc, part) => acc && acc[part] !== undefined ? acc[part] : undefined, obj);
+};
+
+
+/**
+ * Remplace les placeholders dans un template (string, object, array) par des valeurs du contextData.
+ * 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
+    if (template === null || (typeof template !== 'string' && typeof template !== 'object')) {
+        return template;
+    }
+
+    // 2. Gérer les tableaux de manière récursive
+    if (Array.isArray(template)) {
+        return Promise.all(template.map(item => substituteVariables(item, contextData, user)));
+    }
+
+    // 3. Gérer les objets de manière récursive
+    if (typeof template === 'object') {
+        const newObj = {};
+        for (const key in template) {
+            if (Object.prototype.hasOwnProperty.call(template, key)) {
+                const val = await substituteVariables(template[key], contextData, user);
+                safeAssignObject(newObj, key, val);
+            }
+        }
+        return newObj;
+    }
+
+    // --- À partir d'ici, nous savons que `template` est une chaîne de caractères ---
+
+    // 4. Construire le contexte complet pour la substitution
+    const dbCollection = await getCollectionForUser(user);
+    const userEnvVars = await dbCollection.find({ _model: 'env', _user: user.username }).toArray();
+    const userEnv = userEnvVars.reduce((acc, v) => ({ ...acc, [v.name]: v.value }), {});
+
+    // `contextToSearch` contient toutes les données disponibles à sa racine
+    const contextToSearch = { ...contextData, env: userEnv };
+
+    // 5. Logique de résolution de valeur améliorée avec resolvePathValue
+    const findValue = async (key) => {
+        let path = key.trim();
+        if (path.startsWith('context.')) {
+            path = path.substring('context.'.length);
+        }
+        if (path.endsWith('._id')) {
+            const basePath = path.slice(0, -4);
+            const value = await findValue(basePath);
+            return value?._id?.toString(); // Convertit l'ObjectId en string
+        }
+
+        // Gérer les valeurs dynamiques spéciales
+        if (path === 'now') {
+            return new Date().toISOString();
+        } else if (path === 'randomUUID') {
+            return crypto.randomUUID();
+        } else if( path === "baseUrl" ){
+            return process.env.NODE_ENV === 'production' ? 'https://'+getHost()+'/' : 'http://localhost:/'+port;
+        }
+
+        // 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}")
+    const singlePlaceholderMatch = template.match(/^\{([^}]+)\}$/);
+    if (singlePlaceholderMatch) {
+        const key = singlePlaceholderMatch[1];
+        const value = await findValue(key);
+
+        if (value === undefined) {
+            return template; // Placeholder not found, return as is.
+        }
+
+        // If the resolved value is a string, it might contain more placeholders.
+        // We recursively call substituteVariables on it, but only if it's different
+        // from the original template to prevent infinite loops.
+        if (typeof value === 'string' && value !== template) {
+            return substituteVariables(value, contextData, user);
+        }
+
+        // For non-string values or if value is same as template, return the value.
+        return value;
+    }
+
+    // CAS B : La chaîne contient plusieurs placeholders ou mix texte/variables
+    const placeholderRegex = /\{([^}]+)\}/g;
+    const placeholders = [...template.matchAll(placeholderRegex)];
+
+    // Si aucun placeholder trouvé, retourner la chaîne telle quelle
+    if (placeholders.length === 0) {
+        return template;
+    }
+
+    // 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;
+}
+
 
 let logger = null;
 export async function onInit(defaultEngine) {
@@ -27,8 +164,6 @@ export async function onInit(defaultEngine) {
     await scheduleWorkflowTriggers();
 }
 
-export { substituteVariables } from "../filter.js";
-
 /**
  * Déclenche un workflow par son nom et lui passe des données de contexte.
  * C'est la fonction clé à exposer aux endpoints pour lancer des processus métier.