data-primals-engine 1.5.2 → 1.6.1

package/src/modules/data/data.operations.js

@@ -123,7 +123,7 @@ export const dataTypes = {
                     return value;
                 else if (typeof (value) === 'string') {
                     try {
-                        return JSON.parse(value);
+                        return JSON.parse   (value);
                     } catch (e) {
                         return null;
                     }
@@ -459,6 +459,12 @@ export const dataTypes = {
     }
 };
 
+const userStorageCache = new NodeCache({
+    stdTTL: 600, // 10 minutes
+    checkperiod: 120,
+    useClones: false
+});
+
 
 
 let engine, logger;
@@ -466,6 +472,29 @@ export function onInit(defaultEngine) {
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
 
+    // Précalculer périodiquement l'utilisation du stockage pour chaque utilisateur
+    const updateUserStorageUsage = async () => {
+        logger.debug('[Storage] Starting periodic user storage calculation...');
+        try {
+            const usersCollection = getCollection('users');
+            const users = await usersCollection.find({}, { projection: { username: 1 } }).toArray();
+
+            for (const user of users) {
+                try {
+                    const usage = await calculateTotalUserStorageUsage(user);
+                    userStorageCache.set(user.username, usage);
+                } catch (userError) {
+                    logger.error(`[Storage] Failed to calculate storage for user ${user.username}:`, userError);
+                }
+            }
+            logger.debug(`[Storage] User storage calculation finished for ${users.length} users.`);
+        } catch (e) {
+            logger.error('[Storage] Error during periodic user storage calculation:', e);
+        }
+    };
+
+    setInterval(updateUserStorageUsage, 300000); // Toutes les 5 minutes
+    updateUserStorageUsage(); // Lancer une première fois au démarrage
     // Nettoyer périodiquement les relations obsolètes
     setInterval(() => {
         // Nettoyer les relations pour les clés qui n'existent plus
@@ -797,7 +826,11 @@ export const insertData = async (modelName, data, files, user, triggerWorkflow =
         await Event.Trigger("OnDataAdded", "event", "user", userPayload);
 
         // Return valid result
-        return {success: true, insertedIds: insertedIds.map(id => id.toString())}; // Convertir les IDs en string pour la réponse
+        // --- CORRECTION ---
+        // On renvoie l'objet complet du premier document inséré (cas le plus courant pour l'undo)
+        // et la liste complète des IDs pour les cas de bulk insert.
+        const firstInsertedDoc = insertedDocs.length > 0 ? insertedDocs[0] : null;
+        return {success: true, data: firstInsertedDoc, insertedIds: insertedIds.map(id => id.toString())};
 
     } catch (error) { // Attrape les erreurs de permission ou de pushDataUnsecure
         logger.error(`[insertData] Main error during insertion process for model ${modelName}: ${error.message}`, error.stack);
@@ -986,8 +1019,11 @@ async function checkLimits(datas, model, collection, me) {
     const userStorageLimit = await engine.userProvider.getUserStorageLimit(me);
 
     // Vérification des limites utilisateur
-    const currentStorageUsage = await calculateTotalUserStorageUsage(me);
-    if (currentStorageUsage + incomingDataSize > userStorageLimit) {
+    let currentStorageUsage = userStorageCache.get(me.username);
+    if (currentStorageUsage === undefined) {
+        currentStorageUsage = await calculateTotalUserStorageUsage(me); // Fallback si le cache est vide
+    }
+    if ((currentStorageUsage || 0) + incomingDataSize > userStorageLimit) {
         throw new Error(i18n.t("api.data.storageLimitExceeded", {
             limit: Math.round(userStorageLimit / megabytes)
         }));
@@ -1070,7 +1106,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
         const updatePushData = {};
  
         for (const key in data) {
-            if (key.startsWith('_')) continue;
+            if (key.startsWith('_') && !['_env', '_pack'].includes(key)) continue;
  
             if (isPlainObject(data[key]) && data[key].$push !== undefined) {
                 // C'est une opération $push
@@ -1247,6 +1283,43 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
+        // 8. Vérification des limites de stockage avant la mise à jour
+        const originalDocsSize = calculateDataSize(existingDocs);
+        const finalStateForSize = existingDocs.map(doc => {
+            const updatedDoc = { ...doc, ...updateSetData };
+            for (const fieldName in updatePushData) {
+                let itemsToAdd;
+                const pushValue = updatePushData[fieldName];
+                if (isPlainObject(pushValue) && pushValue.$each) {
+                    itemsToAdd = pushValue.$each;
+                } else if (Array.isArray(pushValue)) {
+                    itemsToAdd = pushValue;
+                } else {
+                    itemsToAdd = [pushValue];
+                }
+                if (!Array.isArray(updatedDoc[fieldName])) {
+                    updatedDoc[fieldName] = [];
+                }
+                updatedDoc[fieldName].push(...itemsToAdd);
+            }
+            return updatedDoc;
+        });
+
+        const finalDocsSize = calculateDataSize(finalStateForSize);
+        const sizeDelta = finalDocsSize - originalDocsSize;
+
+        if (sizeDelta > 0) {
+            const userStorageLimit = await engine.userProvider.getUserStorageLimit(user);
+            const currentStorageUsage = await calculateTotalUserStorageUsage(user);
+            if (currentStorageUsage + sizeDelta > userStorageLimit) {
+                throw new Error(i18n.t("api.data.storageLimitExceeded", { limit: Math.round(userStorageLimit / megabytes) }));
+            }
+            const serverCapacity = await checkServerCapacity(sizeDelta);
+            if (!serverCapacity.isSufficient) {
+                throw new Error(i18n.t("api.data.serverStorageFull"));
+            }
+        }
+
         // 8. Calcul du nouveau hash en simulant l'état final
         const finalStateForHash = { ...existingDocs[0], ...updateSetData };
         for (const fieldName in updatePushData) {
@@ -1417,6 +1490,12 @@ export const deleteData = async (modelName, filter, user = {}, triggerWorkflow,
             return ({success: true, deletedCount: 0, message: "No documents found to delete."});
         }
 
+        // --- AMÉLIORATION ---
+        // On détermine le nom du modèle à partir du premier document trouvé.
+        // C'est crucial car la fonction peut être appelée sans `modelName` explicite (ex: via /api/data/:ids).
+        // On suppose que toutes les suppressions dans un même appel concernent le même modèle.
+        const modelNameToInvalidate = modelName || documentsToDelete[0]?._model;
+
         const finalIdsToDelete = []; // IDs des documents qui seront effectivement supprimés
         const idsToInvalidate = [];  // *** AJOUT: IDs à invalider dans le cache ***
 
@@ -1572,9 +1651,19 @@ export const deleteData = async (modelName, filter, user = {}, triggerWorkflow,
                 _id: {$in: finalIdsToDelete}
                 // Le filtre _user est déjà implicite car on a fetch les documents de l'utilisateur
             });
-            invalidateIdsCache(modelName, idsToInvalidate);
-            console.log(`Invalidated cache for ${idsToInvalidate.length} deleted documents in model: ${modelName}`);
 
+            // SOLUTION RADICALE : On invalide TOUT le cache pour ce modèle.
+            // C'est crucial car la suppression affecte les comptes, la pagination, etc.
+            // --- AMÉLIORATION : Invalider aussi les modèles liés ---
+            // Si on supprime un document, toutes les recherches sur les modèles qui le référençaient
+            // deviennent invalides.
+            const relatedModels = await findRelatedModels(modelNameToInvalidate, user);
+            for (const relatedModel of relatedModels) {
+                invalidateModelCache(relatedModel.name);
+                logger.info(`[Cache Invalidation] Also invalidated cache for related model: ${relatedModel.name}`);
+            }
+
+            if (modelNameToInvalidate) invalidateModelCache(modelNameToInvalidate);
             deletedCount = result.deletedCount;
             logger.info(`[deleteData] Successfully deleted ${deletedCount} documents for user ${user?.username}.`);
         } else {
@@ -1674,7 +1763,8 @@ const generateCacheKey = (query, user) => {
             filter: query.filter,
             depth: query.depth,
             autoExpand: query.autoExpand,
-            pack: query.pack
+            pack: query.pack,
+            env: query.env
         },
         user: user.username
     };
@@ -1690,7 +1780,7 @@ const searchCache = new NodeCache({
 });
 
 export const searchData = async (query, user) => {
-    const {page, limit, sort, model, pipelinesPosition, pipelines: customPipelines = [], ids, timeout, pack} = query;
+    const {page, limit, sort, model, pipelinesPosition, pipelines: customPipelines = [], ids, timeout, pack, env} = query;
 
     if (user && user.username !== 'demo' && isLocalUser(user) && (
         !await hasPermission(["API_ADMIN", "API_SEARCH_DATA", "API_SEARCH_DATA_" + model], user) ||
@@ -2142,8 +2232,18 @@ export const searchData = async (query, user) => {
             }
         }
 
+        let envMatchStage;
+        if (env === 'production') {
+            envMatchStage = {$match: {$or: [{'_env': 'production'}, {'_env': {$exists: false}}]}};
+        } else if (env) {
+            envMatchStage = {$match: {'_env': env}};
+        } else {
+            envMatchStage = {$match: {'_env': {$exists: false}}};
+        }
+
         return pipelines.concat(
             [
+                envMatchStage,
                 {$match: {'_pack': pack ? pack : {$exists: false}}},
                 {$match: {$expr: dataNoRelation}}
             ],
@@ -3108,6 +3208,7 @@ export async function installPack(packIdentifier, user = null, lang = 'en', opti
             delete docForInsert._temp_pack_id;
 
             if (user) docForInsert._user = username;
+            
             docForInsert._model = modelName;
             docForInsert._hash = getFieldValueHash(modelDefForHash, docForInsert);
 
@@ -3116,6 +3217,8 @@ export async function installPack(packIdentifier, user = null, lang = 'en', opti
                 _hash: docForInsert._hash,
                 _model: modelName
             };
+
+            if (docForInsert._env) existingQuery._env = docForInsert._env;
             if (user) existingQuery._user = username;
 
             const existingDoc = await collection.findOne(existingQuery, {projection: {_id: 1}});