data-primals-engine 1.5.0 → 1.5.1

package/src/modules/data/data.js

@@ -159,56 +159,6 @@ export async function onInit(defaultEngine) {
 
     // Triggers
 
-    Event.Listen("OnValidateModelStructure", async (modelStructure) =>{
-
-        const objectKeys = Object.keys(modelStructure);
-
-        if( objectKeys.find(o => !["name", "_user", "icon", "history", "locked", "_id", "description", "maxRequestData", "fields"].includes(o)) ){
-            throw new Error(i18n.t('api.model.invalidStructure'));
-        }
-
-        // Vérification du type de name
-        if (typeof modelStructure.name !== 'string' || !modelStructure.name) {
-            throw new Error(i18n.t("api.validate.requiredFieldString", ["name"]));
-        }
-
-        // Vérification du type de description
-        if (typeof modelStructure.description !== 'string') {
-            throw new Error(i18n.t("api.validate.fieldString", ["description"]));
-        }
-
-        // Vérification de la présence et du type du tableau fields
-        if (!Array.isArray(modelStructure.fields)) {
-            throw new Error(i18n.t('api.validate.fieldArray', ["fields"]));
-        }
-
-        // Vérification de chaque champ dans le tableau fields
-        for (const field of modelStructure.fields) {
-            validateField(field);
-        }
-
-        if (modelStructure.constraints) {
-            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));
-            for (const constraint of modelStructure.constraints) {
-                if (constraint.type === 'unique') {
-                    if (!constraint.name || !Array.isArray(constraint.keys) || constraint.keys.length === 0) {
-                        throw new Error('Unique constraint must have a "name" and a non-empty "keys" array.');
-                    }
-                    for (const key of constraint.keys) {
-                        if (!fieldNames.has(key)) {
-                            throw new Error(`Constraint key "${key}" in constraint "${constraint.name}" does not exist as a field in the model.`);
-                        }
-                    }
-                }
-            }
-        }
-
-        return true; // La structure du modèle est valide
-    }, "event", "system");
-
 }
 
 
@@ -327,13 +277,13 @@ export async function handleDemoInitialization(req, res) {
 
         logger.info(`[Demo Init] Installing dynamically generated pack with models: [${models.join(', ')}].`);
 
+        // Create and install pack
+        const result = await installPack(packToInstall, user, req.query.lang || 'en');
+
         await sequential(packs.map(p => {
             return () => installPack(p, user, req.query.lang || 'en');
         }));
 
-        // Create and install pack
-        const result = await installPack(packToInstall, user, req.query.lang || 'en');
-
         if (result.success || result.modifiedCount > 0) {
 
             await Event.Trigger('OnDemoUserAdded', "event", "system", req.me.username);

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

@@ -49,11 +49,11 @@ import {
     checkHash,
     convertDataTypes,
     handleFilesIfNeeded,
-    processDocuments,
-    processFileArray
+    processDocuments
 } from "./data.relations.js";
 import crypto from 'crypto';
 import cronstrue from 'cronstrue/i18n.js';
+import util from "node:util";
 
 const delay = ms => new Promise(res => setTimeout(res, ms));
 const IMPORT_CHUNK_SIZE = 100; // Nombre d'enregistrements à traiter par lot
@@ -361,10 +361,11 @@ export const dataTypes = {
             return false; // Invalid type
         },
         filter: async (value, field, reqFile) => {
-            if (typeof value !== 'object') {
-                return null;
-            }
-
+            // The value is expected to be a GUID string at this point,
+            // which was generated by the `addFile` function.
+            // This filter should not modify it.
+            // The previous implementation returned null for non-objects,
+            // which caused the GUID to be erased.
             return value;
         },
         anonymize: () => null
@@ -815,6 +816,29 @@ export const pushDataUnsecure = async (data, modelName, me, files = {}) => {
         if (datas.length === 0) {
             return [];
         }
+        console.log(util.inspect(files, false,8, true));
+
+        // Traitement des fichiers avant l'insertion.
+        // Cette logique suppose que si des fichiers sont présents, il s'agit d'une insertion unique.
+        if (Object.keys(files).length > 0) {
+
+            const docToModify = datas[0];
+            const fileFields = model.fields.filter(f => f.type === 'file' || (f.type === 'array' && f.itemsType === 'file'));
+
+            for (const field of fileFields) {
+                const fileData = Object.keys(files).filter(f => f.startsWith(field.name+'[')).map(k => files[k]);
+                if (fileData && fileData.length > 0) {
+                    if (field.type === 'file') {
+                        const fileRef = await addFile(fileData[0], me);
+                        docToModify[field.name] = fileRef;
+                    } else if (field.type === 'array' && field.itemsType === 'file') {
+                        const fileArray = Array.isArray(fileData) ? fileData : [fileData];
+                        const fileRefs = await Promise.all(fileArray.map(f => addFile(f, me)));
+                        docToModify[field.name] = fileRefs;
+                    }
+                }
+            }
+        }
 
         // 2. Vérification des limites (en parallèle avec les contraintes)
         const [_, violations] = await Promise.all([
@@ -1037,21 +1061,49 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
         delete updateData._model;
         delete updateData._user;
 
-        // Traitement des fichiers (inchangé)
+        // Traitement des fichiers
         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]']) {
-                if (field.type === 'file') {
-                    updateData[field.name] = await addFile(files[field.name + '[0]'][0], user);
-                } else if (field.type === 'array' && field.itemsType === 'file') {
-                    const currentFiles = existingDocs[0]?.[field.name] || [];
-                    const newFiles = await processFileArray(files[field.name + '[0]'], currentFiles, user);
-                    updateData[field.name] = newFiles;
+            const fieldName = field.name;
+            const uploadedFileOrFiles = files?.[fieldName];
+
+            if (field.type === 'file') {
+                if (uploadedFileOrFiles) { // Un nouveau fichier a été uploadé, on remplace l'ancien
+                    const newFile = Array.isArray(uploadedFileOrFiles) ? uploadedFileOrFiles[0] : uploadedFileOrFiles;
+                    const newFileRef = await addFile(newFile, user);
+                    updateData[fieldName] = newFileRef;
+
+                    // Supprimer l'ancien fichier s'il existait
+                    const oldFileGuid = existingDocs[0]?.[fieldName];
+                    if (oldFileGuid) {
+                        await removeFile(oldFileGuid, user);
+                    }
+                } else if (data[fieldName] === null && existingDocs[0]?.[fieldName]) {
+                    // Le champ a été vidé, on supprime l'ancien fichier
+                    await removeFile(existingDocs[0][fieldName], user);
+                }
+            } else if (field.type === 'array' && field.itemsType === 'file') {
+                // Les GUIDs des fichiers existants à conserver sont passés dans `data`
+                const filesToKeepGuids = data[fieldName] || [];
+                const currentGuidsInDb = existingDocs[0]?.[fieldName] || [];
+                let finalGuids = [...filesToKeepGuids];
+
+                if (uploadedFileOrFiles) { // Ajout des nouveaux fichiers uploadés
+                    const newFilesArray = Array.isArray(uploadedFileOrFiles) ? uploadedFileOrFiles : [uploadedFileOrFiles];
+                    const newFileRefs = await Promise.all(newFilesArray.map(f => addFile(f, user)));
+                    finalGuids.push(...newFileRefs);
                 }
+
+                // Déterminer quels fichiers ont été retirés et les supprimer du stockage
+                const filesToKeepSet = new Set(filesToKeepGuids);
+                const filesToRemoveGuids = currentGuidsInDb.filter(guid => !filesToKeepSet.has(guid));
+                await Promise.all(filesToRemoveGuids.map(guid => removeFile(guid, user)));
+
+                updateData[fieldName] = finalGuids;
             }
         }
 
-        // 4. Validation adaptée pour patch ou edit (inchangé)
+        // 4. Validation adaptée pour patch ou edit
         if (!isPatch) {
             const dataToValidate = {...existingDocs[0], ...updateData};
             await validateModelData(dataToValidate, model, false);
@@ -1059,7 +1111,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             await validateModelData(updateData, model, true);
         }
 
-        // 5. Vérification des champs uniques (inchangé)
+        // 5. Vérification des champs uniques
         const uniqueFields = model.fields.filter(f => f.unique);
         for (const field of uniqueFields) {
             if (updateData[field.name] !== undefined) {
@@ -1078,7 +1130,7 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        // 6. Traitement des relations (inchangé)
+        // 6. Traitement des relations
         const relationFields = model.fields.filter(f => f.type === 'relation');
         for (const field of relationFields) {
             if (updateData[field.name] !== undefined) {
@@ -1102,12 +1154,12 @@ const internalEditOrPatchData = async (modelName, filter, data, files, user, isP
             }
         }
 
-        // 7. Application des filtres de champ (ex: hashage de mot de passe) (inchangé)
+        // 7. Application des filtres de champ (ex: hashage de mot de passe)
         for (const field of model.fields) {
-            if (updateData[field.name] !== undefined && dataTypes[field.type]?.filter) {
+            // On saute les champs 'file' car ils ont déjà été traités
+            if (field.type !== 'file' && field.itemsType !== 'file' && updateData[field.name] !== undefined && dataTypes[field.type]?.filter) {
                 updateData[field.name] = await dataTypes[field.type].filter(
-                    field.type === 'file' ? null : updateData[field.name],
-                    field
+                    updateData[field.name], field
                 );
             }
         }
@@ -1828,7 +1880,7 @@ export const searchData = async (query, user) => {
                         [fi.name + "_details_temp"]: 0
                     }
                 });
-            } else if (fi.type === 'array' && fi.itemsType === 'file' && depthParam !== 1) {
+            } else if (fi.type === 'array' && fi.itemsType === 'file') {
                 pipelinesLookups.push(
                     {
                         $lookup: {
@@ -2858,11 +2910,10 @@ export async function installPack(packIdentifier, user = null, lang = 'en', opti
             ? await modelsCollection.find({_user: username}).toArray()
             : await modelsCollection.find({_user: {$exists: false}}).toArray();
 
-        console.log("EXISTING", existingModels);
-
         const existingModelNames = existingModels.map(m => m.name);
 
-        for (const modelOrName of pack.models) {
+        for (let i = 0; i < pack.models.length; i++) {
+            const modelOrName = pack.models[i];
             try {
                 const modelName = typeof modelOrName === 'string' ? modelOrName : modelOrName?.name;
                 if (!modelName) throw new Error('Model definition in pack is missing a name.');
@@ -2894,8 +2945,8 @@ export async function installPack(packIdentifier, user = null, lang = 'en', opti
                 await validateModelStructure(preparedModel);
                 await modelsCollection.insertOne(preparedModel);
                 summary.models.installed.push(modelName);
-
             } catch (e) {
+                logger.error(e);
                 const modelName = typeof modelOrName === 'string' ? modelOrName : modelOrName?.name || 'unknown';
                 errors.push(`Failed to install model '${modelName}': ${e.message}`);
                 summary.models.failed.push(modelName);