@growy/strapi-plugin-encrypted-field 1.7.1 → 1.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@growy/strapi-plugin-encrypted-field",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "description": "Campo personalizado de texto cifrado para Strapi",
   "strapi": {
     "name": "encrypted-field",

package/server/bootstrap.js

@@ -4,40 +4,69 @@ module.exports = ({ strapi }) => {
   
   const models = Object.values(strapi.contentTypes);
   
+  strapi.log.info(`Total de modelos encontrados: ${models.length}`);
+  
   models.forEach((model) => {
-    const hasEncryptedFields = Object.values(model.attributes || {}).some(isEncryptedField);
+    const attributes = model.attributes || {};
+    
+    // Debug: mostrar todos los campos del modelo
+    strapi.log.debug(`Modelo ${model.uid}: ${Object.keys(attributes).length} atributos`);
+    
+    const encryptedFields = Object.entries(attributes)
+      .filter(([key, attr]) => {
+        const isEncrypted = isEncryptedField(attr);
+        if (attr.customField) {
+          strapi.log.debug(`  - ${key}: customField = ${attr.customField}, isEncrypted = ${isEncrypted}`);
+        }
+        return isEncrypted;
+      })
+      .map(([key]) => key);
     
-    if (!hasEncryptedFields) return;
+    if (encryptedFields.length === 0) return;
 
     const uid = model.uid;
     
-    strapi.log.info(`Registrando lifecycles de cifrado para ${uid}`);
+    strapi.log.info(`✓ Registrando lifecycles de cifrado para ${uid} - Campos: ${encryptedFields.join(', ')}`);
 
   
     strapi.db.lifecycles.subscribe({
       models: [uid],
       
       async beforeCreate(event) {
+        const { data } = event.params;
+        
+        strapi.log.info(`[beforeCreate] Evento recibido para ${event.model?.uid}`);
+        strapi.log.info(`[beforeCreate] Data recibida: ${JSON.stringify(data)}`);
+        
         if (!event.model?.uid) return;
         
-        const { data } = event.params;
         const currentModel = strapi.getModel(event.model.uid);
         
         if (!currentModel?.attributes) return;
         
         for (const [key, attribute] of Object.entries(currentModel.attributes)) {
           if (!isEncryptedField(attribute)) continue;
+          
+          strapi.log.info(`[beforeCreate] Campo cifrado detectado: ${key}`);
+          
           if (Object.prototype.hasOwnProperty.call(data, key)) {
             const value = data[key];
-            if (value === null || value === undefined || value === '') continue;
+            
+            strapi.log.info(`[beforeCreate] Valor del campo ${key}: ${value}`);
+            
+            if (value === null || value === undefined || value === '') {
+              strapi.log.info(`[beforeCreate] Valor vacío, saltando cifrado`);
+              continue;
+            }
             
             const validation = validateValue(value, attribute);
             if (!validation.valid) {
               throw new Error(`Validación fallida para el campo "${key}": ${validation.error}`);
             }
             
-            strapi.log.info(`Cifrando campo ${key} en ${event.model.uid}`);
+            strapi.log.info(`✓ Cifrando campo ${key} con valor: ${value}`);
             data[key] = encrypt(value, strapi);
+            strapi.log.info(`✓ Campo ${key} cifrado exitosamente`);
           }
         }
       },