data-primals-engine 1.5.2 → 1.6.1

package/src/modules/data/data.validation.js

@@ -17,7 +17,7 @@ export function onInit(defaultEngine) {
 
         const objectKeys = Object.keys(modelStructure);
 
-        if( objectKeys.find(o => !["name", "_user", "icon", "history", "locked", "_id", "description", "maxRequestData", "fields", "tags"].includes(o)) ){
+        if( objectKeys.find(o => !["name", "_user", "icon", "history", "locked", "_id", "description", "maxRequestData", "fields", "tags", "constraints"].includes(o)) ){
             throw new Error(i18n.t('api.model.invalidStructure'));
         }
 
@@ -51,7 +51,7 @@ export function onInit(defaultEngine) {
             if (!Array.isArray(modelStructure.constraints)) {
                 throw new Error('Model "constraints" property must be an array.');
             }
-            const fieldNames = new Set(modelStructure.fields.map(f => f.name));
+            const fieldNames = new Set(modelStructure.fields.map(f => f.name).concat(['_user']));
             for (const constraint of modelStructure.constraints) {
                 if (constraint.type === 'unique') {
                     if (!constraint.name || !Array.isArray(constraint.keys) || constraint.keys.length === 0) {

package/src/modules/file.js

@@ -1,248 +1,248 @@
-
-// Nouvelle fonction pour ajouter un fichier privé
-import {maxPrivateFileSize, megabytes} from "../constants.js";
-import {isLocalUser} from "../data.js";
-import i18n from "../../src/i18n.js";
-import {getCollection} from "./mongodb.js";
-import {getFileExtension, isGUID, uuidv4} from "../core.js";
-import path from "node:path";
-import process from "node:process";
-import fs from "node:fs";
-import { checkServerCapacity} from "./data/index.js";
-import crypto from "node:crypto";
-import * as tar from "tar";
-import {promisify} from "node:util";
-import {calculateTotalUserStorageUsage, hasPermission} from "./user.js";
-import {Logger} from "../gameObject.js";
-import {deleteFromS3, getUserS3Config, uploadToS3} from "./bucket.js";
-import {Config} from "../config.js";
-
-const pbkdf2Async = promisify(crypto.pbkdf2);
-
-let engine, logger;
-const fsPromises = fs.promises;
-
-// Encryption settings
-const algorithm = 'aes-256-cbc'; // Algorithm to use
-const iterations = 100000; // Number of iterations for PBKDF2
-const keyLength = 32; // Key length for AES-256
-const ivLength = 16; // IV length for AES
-
-// Function to derive a key and IV from a passphrase and salt
-async function deriveKeyAndIV(password, salt) {
-    const key = await pbkdf2Async(password, salt, iterations, keyLength, 'sha256');
-    // L'IV n'est plus dérivé ici.
-    return { key };
-}
-
-
-export const unzip = async (file) => {
-    await tar.extract({ file: file, gzip: true, sync: true });
-}
-
-export const zip = async (filename) => {
-    await tar.create({ gzip: true, sync: true, file: filename+'.gz' }, [filename])
-}
-export const addFile = async (file, user) => {
-    if (!file) throw new Error("Le fichier est requis");
-
-    // Rendre compatible avec formidable v2 (path, name, type) et v3 (filepath, originalFilename, mimetype)
-    const filePath = file.path || file.filepath;
-    const originalName = file.name || file.originalFilename;
-    const mimeType = file.type || file.mimetype;
-
-    if (!filePath || !originalName) {
-        throw new Error("Les informations du fichier (nom, chemin) sont incomplètes.");
-    }
-
-    const m = Config.Get('maxPrivateFileSize', maxPrivateFileSize);
-    if (file.size > m) {
-        throw new Error(`La taille du fichier dépasse la limite autorisée (${m / megabytes} Mo).`);
-    }
-
-    if (user.username !== 'demo' && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_UPLOAD_FILE"], user)) {
-        throw new Error(i18n.t("api.permission.uploadFile"));
-    }
-
-    const incomingDataSize = file.size;
-
-    const userStorageLimit = await engine.userProvider.getUserStorageLimit(user);
-    const currentStorageUsage = await calculateTotalUserStorageUsage(user);
-
-    if (currentStorageUsage + incomingDataSize > userStorageLimit) {
-        throw new Error(i18n.t("api.data.storageLimitExceeded", { limit: Math.round(userStorageLimit / megabytes) }));
-    }
-
-    const serverCapacity = await checkServerCapacity(incomingDataSize);
-    if (!serverCapacity.isSufficient) {
-        throw new Error(i18n.t("api.data.serverStorageFull", "Le serveur a atteint sa capacité de stockage maximale. Veuillez réessayer plus tard."));
-    }
-
-    // Générer un GUID pour le fichier
-    const guid = uuidv4();
-    const s3Config = await getUserS3Config(user);
-    const extension = getFileExtension(originalName);
-    const newFilename = `${guid}.${extension}`;
-
-    const fileData = {
-        guid: guid,
-        name: originalName, // Nom original du fichier
-        filename: newFilename, // Nom du fichier stocké (GUID + extension)
-        size: file.size,
-        mimeType: mimeType,
-        createdAt: new Date(),
-        user: user.username,
-        mainUser: user._user
-    };
-
-    if (s3Config && s3Config.bucketName && s3Config.accessKeyId && s3Config.secretAccessKey) {
-        try {
-            await uploadToS3(s3Config, filePath, newFilename);
-
-            fileData.storage = 's3';
-            logger.info(`Fichier ${newFilename} téléversé sur le bucket S3 ${s3Config.bucketName}.`);
-        } catch (error) {
-            logger.error(`Le téléversement S3 a échoué pour ${originalName}: ${error.message}`, error);
-            throw new Error("Le téléversement S3 a échoué.");
-        } finally {
-            // Nettoyer le fichier temporaire uploadé par express-formidable
-            await fsPromises.unlink(filePath).catch(e => logger.warn(`Échec de la suppression du fichier temporaire ${filePath}: ${e.message}`));
-        }
-    } else {
-        // Sauvegarde locale
-        const uploadDir = path.join(process.cwd(), "uploads", "private");
-        if (!fs.existsSync(uploadDir)) {
-            fs.mkdirSync(uploadDir, { recursive: true });
-        }
-        const newPath = path.join(uploadDir, newFilename);
-
-        try {
-            // Utiliser copyFile puis unlink au lieu de rename pour éviter les erreurs cross-device (EXDEV)
-            // qui peuvent survenir dans des environnements conteneurisés comme GitHub Actions.
-            await fsPromises.copyFile(filePath, newPath);
-            await fsPromises.unlink(filePath);
-            fileData.storage = 'local';
-            fileData.path = newPath; // Le chemin complet pour les fichiers locaux
-            logger.info(`Fichier ${newFilename} sauvegardé localement dans ${newPath}.`);
-        } catch (error) {
-            logger.error(`Le stockage du fichier local a échoué pour ${originalName}: ${error.message}`, error);
-            // Essayer de nettoyer le fichier temporaire même si le renommage échoue
-            await fsPromises.unlink(filePath).catch(e => logger.warn(`Échec de la suppression du fichier temporaire ${filePath}: ${e.message}`));
-            throw new Error("Le stockage du fichier local a échoué.");
-        }
-    }
-
-    const filesCollection = await getCollection("files");
-    await filesCollection.insertOne(fileData);
-
-    return guid;
-};
-
-/**
- * Récupère les métadonnées d'un fichier depuis la base de données.
- * @param {string} guid - Le GUID du fichier.
- * @returns {Promise<object|null>} L'objet de métadonnées du fichier ou null si non trouvé.
- */
-export const getFile = async (guid) => {
-    const filesCollection = await getCollection("files");
-    return await filesCollection.findOne({ guid });
-};
-
-export const removeFile = async (guid, user) => {
-    if (!guid) return false;
-    if (!isGUID(guid)) throw new Error("Le GUID du fichier n'est pas valide.");
-
-    const fileData = await getFile(guid);
-    if (!fileData) {
-        logger.info(`Tentative de suppression d'un fichier inexistant avec le GUID : ${guid}`, 'warn');
-        return;
-    }
-
-    if (fileData.storage === 's3') {
-        const s3Config = await getUserS3Config(user);
-        if (s3Config && s3Config.bucketName) { // Correction: bucketName au lieu de bucket
-            try {
-                await deleteFromS3(s3Config, fileData.filename);
-                logger.info(`Fichier ${fileData.filename} supprimé du bucket S3 ${s3Config.bucketName}.`);
-            } catch (error) {
-                logger.info(`La suppression S3 a échoué pour ${fileData.filename}: ${error.message}`, 'error');
-                throw new Error("La suppression S3 a échoué.");
-            }
-        } else {
-            logger.info(`Configuration S3 non trouvée pour l'utilisateur, impossible de supprimer le fichier ${fileData.filename} de S3.`, 'error');
-            throw new Error("Configuration S3 non trouvée, impossible de supprimer le fichier.");
-        }
-    } else if (fileData.storage === 'local') {
-        try {
-            if (fileData.path && fs.existsSync(fileData.path)) {
-                await fsPromises.unlink(fileData.path);
-                logger.info(`Fichier local ${fileData.path} supprimé.`);
-            } else {
-                logger.info(`Fichier local non trouvé au chemin ${fileData.path}, mais suppression de l'enregistrement en BDD.`, 'warn');
-            }
-        } catch (error) {
-            logger.info(`La suppression du fichier local a échoué pour ${fileData.path}: ${error.message}`, 'error');
-            throw new Error("La suppression du fichier local a échoué.");
-        }
-    }
-
-    const filesCollection = await getCollection("files");
-    await filesCollection.deleteOne({ guid });
-};
-
-
-
-
-// Function to encrypt the file content
-export async function encryptFile(filePath, password) {
-    try {
-        const salt = crypto.randomBytes(16);
-        const iv = crypto.randomBytes(ivLength);
-
-        // On ne dérive que la clé
-        const { key } = await deriveKeyAndIV(password, salt);
-
-        const fileData = await fs.promises.readFile(filePath);
-        const cipher = crypto.createCipheriv(algorithm, key, iv);
-        const encryptedData = Buffer.concat([cipher.update(fileData), cipher.final()]);
-
-        // On it : [salt][iv][données chiffrées]
-        await fs.promises.writeFile(filePath, Buffer.concat([salt, iv, encryptedData]));
-
-        console.log('File encrypted successfully.', filePath);
-    } catch (error) {
-        console.error('Error during encryption:', error.message);
-    }
-}
-// Function to decrypt the file content
-export async function decryptFile(filePath, password) {
-    try {
-        const fileData = await fs.promises.readFile(filePath);
-
-        // Extraire le sel, l'IV et les données
-        const salt = fileData.slice(0, 16);
-        // NOUVEAU: Extraire l'IV qui suit le sel
-        const iv = fileData.slice(16, 16 + ivLength);
-        const encryptedData = fileData.slice(16 + ivLength);
-
-        // On dérive la même clé en utilisant le sel extrait
-        const { key } = await deriveKeyAndIV(password, salt);
-
-        // On utilise l'IV extrait pour le déchiffrement
-        const decipher = crypto.createDecipheriv(algorithm, key, iv);
-        const decryptedData = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
-
-        await fs.promises.writeFile(filePath, decryptedData);
-
-        console.log('File decrypted successfully.');
-    } catch (error) {
-        console.error('Error during decryption:', error.message);
-        // Relancer l'erreur peut être utile pour que l'appelant sache que ça a échoué
-        throw new Error(`Decryption failed: ${error.message}`);
-    }
-}
-
-export async function onInit(defaultEngine) {
-    engine = defaultEngine;
-    logger = engine.getComponent(Logger);
+
+// Nouvelle fonction pour ajouter un fichier privé
+import {maxPrivateFileSize, megabytes} from "../constants.js";
+import {isLocalUser} from "../data.js";
+import i18n from "../../src/i18n.js";
+import {getCollection} from "./mongodb.js";
+import {getFileExtension, isGUID, uuidv4} from "../core.js";
+import path from "node:path";
+import process from "node:process";
+import fs from "node:fs";
+import { checkServerCapacity} from "./data/index.js";
+import crypto from "node:crypto";
+import * as tar from "tar";
+import {promisify} from "node:util";
+import {calculateTotalUserStorageUsage, hasPermission} from "./user.js";
+import {Logger} from "../gameObject.js";
+import {deleteFromS3, getUserS3Config, uploadToS3} from "./bucket.js";
+import {Config} from "../config.js";
+
+const pbkdf2Async = promisify(crypto.pbkdf2);
+
+let engine, logger;
+const fsPromises = fs.promises;
+
+// Encryption settings
+const algorithm = 'aes-256-cbc'; // Algorithm to use
+const iterations = 100000; // Number of iterations for PBKDF2
+const keyLength = 32; // Key length for AES-256
+const ivLength = 16; // IV length for AES
+
+// Function to derive a key and IV from a passphrase and salt
+async function deriveKeyAndIV(password, salt) {
+    const key = await pbkdf2Async(password, salt, iterations, keyLength, 'sha256');
+    // L'IV n'est plus dérivé ici.
+    return { key };
+}
+
+
+export const unzip = async (file) => {
+    await tar.extract({ file: file, gzip: true, sync: true });
+}
+
+export const zip = async (filename) => {
+    await tar.create({ gzip: true, sync: true, file: filename+'.gz' }, [filename])
+}
+export const addFile = async (file, user) => {
+    if (!file) throw new Error("Le fichier est requis");
+
+    // Rendre compatible avec formidable v2 (path, name, type) et v3 (filepath, originalFilename, mimetype)
+    const filePath = file.path || file.filepath;
+    const originalName = file.name || file.originalFilename;
+    const mimeType = file.type || file.mimetype;
+
+    if (!filePath || !originalName) {
+        throw new Error("Les informations du fichier (nom, chemin) sont incomplètes.");
+    }
+
+    const m = Config.Get('maxPrivateFileSize', maxPrivateFileSize);
+    if (file.size > m) {
+        throw new Error(`La taille du fichier dépasse la limite autorisée (${m / megabytes} Mo).`);
+    }
+
+    if (user.username !== 'demo' && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_UPLOAD_FILE"], user)) {
+        throw new Error(i18n.t("api.permission.uploadFile"));
+    }
+
+    const incomingDataSize = file.size;
+
+    const userStorageLimit = await engine.userProvider.getUserStorageLimit(user);
+    const currentStorageUsage = await calculateTotalUserStorageUsage(user);
+
+    if (currentStorageUsage + incomingDataSize > userStorageLimit) {
+        throw new Error(i18n.t("api.data.storageLimitExceeded", { limit: Math.round(userStorageLimit / megabytes) }));
+    }
+
+    const serverCapacity = await checkServerCapacity(incomingDataSize);
+    if (!serverCapacity.isSufficient) {
+        throw new Error(i18n.t("api.data.serverStorageFull", "Le serveur a atteint sa capacité de stockage maximale. Veuillez réessayer plus tard."));
+    }
+
+    // Générer un GUID pour le fichier
+    const guid = uuidv4();
+    const s3Config = await getUserS3Config(user);
+    const extension = getFileExtension(originalName);
+    const newFilename = `${guid}.${extension}`;
+
+    const fileData = {
+        guid: guid,
+        name: originalName, // Nom original du fichier
+        filename: newFilename, // Nom du fichier stocké (GUID + extension)
+        size: file.size,
+        mimeType: mimeType,
+        createdAt: new Date(),
+        user: user.username,
+        mainUser: user._user
+    };
+
+    if (s3Config && s3Config.bucketName && s3Config.accessKeyId && s3Config.secretAccessKey) {
+        try {
+            await uploadToS3(s3Config, filePath, newFilename);
+
+            fileData.storage = 's3';
+            logger.info(`Fichier ${newFilename} téléversé sur le bucket S3 ${s3Config.bucketName}.`);
+        } catch (error) {
+            logger.error(`Le téléversement S3 a échoué pour ${originalName}: ${error.message}`, error);
+            throw new Error("Le téléversement S3 a échoué.");
+        } finally {
+            // Nettoyer le fichier temporaire uploadé par express-formidable
+            await fsPromises.unlink(filePath).catch(e => logger.warn(`Échec de la suppression du fichier temporaire ${filePath}: ${e.message}`));
+        }
+    } else {
+        // Sauvegarde locale
+        const uploadDir = path.join(process.cwd(), "uploads", "private");
+        if (!fs.existsSync(uploadDir)) {
+            fs.mkdirSync(uploadDir, { recursive: true });
+        }
+        const newPath = path.join(uploadDir, newFilename);
+
+        try {
+            // Utiliser copyFile puis unlink au lieu de rename pour éviter les erreurs cross-device (EXDEV)
+            // qui peuvent survenir dans des environnements conteneurisés comme GitHub Actions.
+            await fsPromises.copyFile(filePath, newPath);
+            await fsPromises.unlink(filePath);
+            fileData.storage = 'local';
+            fileData.path = newPath; // Le chemin complet pour les fichiers locaux
+            logger.info(`Fichier ${newFilename} sauvegardé localement dans ${newPath}.`);
+        } catch (error) {
+            logger.error(`Le stockage du fichier local a échoué pour ${originalName}: ${error.message}`, error);
+            // Essayer de nettoyer le fichier temporaire même si le renommage échoue
+            await fsPromises.unlink(filePath).catch(e => logger.warn(`Échec de la suppression du fichier temporaire ${filePath}: ${e.message}`));
+            throw new Error("Le stockage du fichier local a échoué.");
+        }
+    }
+
+    const filesCollection = await getCollection("files");
+    await filesCollection.insertOne(fileData);
+
+    return guid;
+};
+
+/**
+ * Récupère les métadonnées d'un fichier depuis la base de données.
+ * @param {string} guid - Le GUID du fichier.
+ * @returns {Promise<object|null>} L'objet de métadonnées du fichier ou null si non trouvé.
+ */
+export const getFile = async (guid) => {
+    const filesCollection = await getCollection("files");
+    return await filesCollection.findOne({ guid });
+};
+
+export const removeFile = async (guid, user) => {
+    if (!guid) return false;
+    if (!isGUID(guid)) throw new Error("Le GUID du fichier n'est pas valide.");
+
+    const fileData = await getFile(guid);
+    if (!fileData) {
+        logger.info(`Tentative de suppression d'un fichier inexistant avec le GUID : ${guid}`, 'warn');
+        return;
+    }
+
+    if (fileData.storage === 's3') {
+        const s3Config = await getUserS3Config(user);
+        if (s3Config && s3Config.bucketName) { // Correction: bucketName au lieu de bucket
+            try {
+                await deleteFromS3(s3Config, fileData.filename);
+                logger.info(`Fichier ${fileData.filename} supprimé du bucket S3 ${s3Config.bucketName}.`);
+            } catch (error) {
+                logger.info(`La suppression S3 a échoué pour ${fileData.filename}: ${error.message}`, 'error');
+                throw new Error("La suppression S3 a échoué.");
+            }
+        } else {
+            logger.info(`Configuration S3 non trouvée pour l'utilisateur, impossible de supprimer le fichier ${fileData.filename} de S3.`, 'error');
+            throw new Error("Configuration S3 non trouvée, impossible de supprimer le fichier.");
+        }
+    } else if (fileData.storage === 'local') {
+        try {
+            if (fileData.path && fs.existsSync(fileData.path)) {
+                await fsPromises.unlink(fileData.path);
+                logger.info(`Fichier local ${fileData.path} supprimé.`);
+            } else {
+                logger.info(`Fichier local non trouvé au chemin ${fileData.path}, mais suppression de l'enregistrement en BDD.`, 'warn');
+            }
+        } catch (error) {
+            logger.info(`La suppression du fichier local a échoué pour ${fileData.path}: ${error.message}`, 'error');
+            throw new Error("La suppression du fichier local a échoué.");
+        }
+    }
+
+    const filesCollection = await getCollection("files");
+    await filesCollection.deleteOne({ guid });
+};
+
+
+
+
+// Function to encrypt the file content
+export async function encryptFile(filePath, password) {
+    try {
+        const salt = crypto.randomBytes(16);
+        const iv = crypto.randomBytes(ivLength);
+
+        // On ne dérive que la clé
+        const { key } = await deriveKeyAndIV(password, salt);
+
+        const fileData = await fs.promises.readFile(filePath);
+        const cipher = crypto.createCipheriv(algorithm, key, iv);
+        const encryptedData = Buffer.concat([cipher.update(fileData), cipher.final()]);
+
+        // On it : [salt][iv][données chiffrées]
+        await fs.promises.writeFile(filePath, Buffer.concat([salt, iv, encryptedData]));
+
+        console.log('File encrypted successfully.', filePath);
+    } catch (error) {
+        console.error('Error during encryption:', error.message);
+    }
+}
+// Function to decrypt the file content
+export async function decryptFile(filePath, password) {
+    try {
+        const fileData = await fs.promises.readFile(filePath);
+
+        // Extraire le sel, l'IV et les données
+        const salt = fileData.slice(0, 16);
+        // NOUVEAU: Extraire l'IV qui suit le sel
+        const iv = fileData.slice(16, 16 + ivLength);
+        const encryptedData = fileData.slice(16 + ivLength);
+
+        // On dérive la même clé en utilisant le sel extrait
+        const { key } = await deriveKeyAndIV(password, salt);
+
+        // On utilise l'IV extrait pour le déchiffrement
+        const decipher = crypto.createDecipheriv(algorithm, key, iv);
+        const decryptedData = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
+
+        await fs.promises.writeFile(filePath, decryptedData);
+
+        console.log('File decrypted successfully.');
+    } catch (error) {
+        console.error('Error during decryption:', error.message);
+        // Relancer l'erreur peut être utile pour que l'appelant sache que ça a échoué
+        throw new Error(`Decryption failed: ${error.message}`);
+    }
+}
+
+export async function onInit(defaultEngine) {
+    engine = defaultEngine;
+    logger = engine.getComponent(Logger);
 }

package/src/modules/user.js

@@ -108,7 +108,7 @@ export async function onInit(defaultEngine) {
  * @returns {Promise<Set<string>>} Un Set contenant les noms de toutes les permissions actives.
  * @private
  */
-export async function getUserActivePermissions(user) {
+export async function getUserActivePermissions(user, env = null) {
     const datasCollection = await getCollectionForUser(user);
     const now = new Date();
     const activePermissions = new Set();
@@ -139,12 +139,17 @@ export async function getUserActivePermissions(user) {
     // --- ÉTAPE 2: Appliquer les exceptions de permission ---
     const exceptions = await datasCollection.aggregate([
         {
-            $match: {
+            $match: { // Filtre de base pour les exceptions de l'utilisateur
                 _model: "userPermission",
-                user: user._id, // Pas besoin de convertir en ObjectId si c'est déjà une string
-                $or: [
-                    { expiresAt: { $exists: false } },
-                    { expiresAt: { $gt: now } }
+                user: user._id,
+                $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 } }] }
                 ]
             }
         },
@@ -193,7 +198,7 @@ export async function getUserActivePermissions(user) {
  * @param {object} user - L'objet utilisateur authentifié.
  * @returns {Promise<boolean>} - True si l'utilisateur a la permission, sinon false.
  */
-export async function hasPermission(permissionNames, user) {
+export async function hasPermission(permissionNames, user, env = null) {
     // Garde la compatibilité pour les utilisateurs non-locaux (ex: système)
     if (!isLocalUser(user)) {
         const userRoles = new Set(user.roles || []);
@@ -209,10 +214,10 @@ export async function hasPermission(permissionNames, user) {
         }
 
         // 1. Obtenir l'ensemble final et à jour des permissions de l'utilisateur
-        const activePermissions = await getUserActivePermissions(user);
+        const activePermissions = await getUserActivePermissions(user, env);
 
         // 2. Vérifier si au moins une des permissions requises est dans l'ensemble des permissions actives
-        return requiredPermissions.some(pName => activePermissions.has(pName));
+        return requiredPermissions.some(pName => activePermissions.has(pName)) || false;
 
     } catch (e) {
         logger.error("Erreur lors de la vérification des permissions :", e);

package/src/packs.js

@@ -348,8 +348,8 @@ This pack sets up an automated ecosystem for your store:
                     "env":envSmtp,
                     "taxonomy": [
                         { "name": "E-commerce", "type": "category" },
-                        { "name": "Clothes", "type": "category", "parent": { "$find": { "name": "E-commerce" } } },
-                        { "name": "Electronics", "type": "category", "parent": { "$find": { "name": "E-commerce" } } }
+                        { "name": "Clothes", "type": "category", "parent": { "$link": { "name": "E-commerce" } } },
+                        { "name": "Electronics", "type": "category", "parent": { "$link": { "name": "E-commerce" } } }
                     ],
                     "brand": [
                         { "name": "Brand A" },

package/src/providers.js

@@ -169,7 +169,7 @@ export class DefaultUserProvider extends UserProvider {
             }
         }
 
-        // Priorité 2: PasF de session, mais on vérifie la présence d'un cookie "username" pour la démo.
+        // Priorité 2: Pas de session, mais on vérifie la présence d'un cookie "username" pour la démo.
         const demoUsername = req.cookies?.username;
         if (demoUsername && typeof demoUsername === 'string' && this.isDemoUser(demoUsername)) {
             // On a trouvé un cookie de démo. On crée l'objet utilisateur correspondant.
@@ -180,7 +180,7 @@ export class DefaultUserProvider extends UserProvider {
             }
         }
 
-        // Priorité 2: PasF de session, mais on vérifie la présence d'un cookie "username" pour la démo.
+        // Priorité 2: PasF de session, mais on vérifie la présence d'un user dans la requete
         const user = req.query._user;
         if (user && typeof user === 'string' && this.isDemoUser(user)) {
             const demoUser = await this.findUserByUsername(user);