@growy/strapi-plugin-encrypted-field 2.1.9 → 2.3.0

package/README.md

@@ -16,11 +16,10 @@ Plugin oficial de **Growy AI** para Strapi que proporciona un campo personalizad
 - ✅ **UI mejorada** con controles de visibilidad y copiar al portapapeles
 - ✅ **Valores ocultos** por defecto con opción de mostrar/ocultar
 - ✅ **Notificaciones** de confirmación al copiar valores
-- ✅ **Sistema de auditoría** que registra quién accede a datos sensibles
 - ✅ **Gestión de claves robusta** con validación y mensajes de error claros
 - ✅ **Datos cifrados** en base de datos con IV único y Auth Tag
 - ✅ **Reutilizable** en cualquier colección o componente
-- ✅ **Compatible con Strapi 5** - Utiliza componentes actualizados del Design System v2
+- ✅ **Soporte completo** para componentes anidados y estructuras complejas
 
 ## Instalación
 
@@ -99,12 +98,10 @@ npm run develop
 
 ## Requisitos
 
-- **Strapi**: v5.0.0 o superior (compatible con Design System v2)
+- **Strapi**: v5.0.0 o superior
 - **Node.js**: 18.x - 22.x
 - **npm**: 6.0.0 o superior
 
-⚠️ **Nota sobre Strapi 5**: Esta versión utiliza los componentes actualizados del Design System v2. Si tienes problemas con componentes de layout, asegúrate de que tu proyecto esté actualizado a Strapi 5.
-
 ## Validación de datos
 
 El plugin soporta validación antes del cifrado:
@@ -123,46 +120,6 @@ El plugin soporta validación antes del cifrado:
 
 Si el valor no cumple con el patrón, se lanzará un error antes de cifrar.
 
-## Auditoría de seguridad
-
-El plugin incluye un sistema completo de auditoría que registra todas las acciones sensibles realizadas sobre los campos cifrados:
-
-### Funcionalidades de auditoría
-
-- **Registro automático** de accesos a datos sensibles
-- **Acciones rastreadas**:
-  - ✅ **Vista** de valores cifrados (al mostrar contenido oculto)
-  - ✅ **Copia** de valores al portapapeles
-  - ✅ **Descifrado** de datos (próximamente)
-- **Información registrada**:
-  - Usuario que realizó la acción
-  - Campo y colección afectados
-  - ID de entrada modificada
-  - Dirección IP y User-Agent del navegador
-  - Timestamp preciso de la acción
-
-### Acceso a logs de auditoría
-
-1. **En el panel de administración**, ve al menú lateral izquierdo
-2. **Busca el ítem del plugin** "Encrypted Field" (con el ícono 🔒)
-3. **Dentro encontrarás** la opción **"Logs de Auditoría"**
-4. **Haz clic** para ver la tabla con todos los eventos registrados
-5. **Usa la paginación** para navegar por eventos antiguos
-
-**Ubicación exacta:** Menú izquierdo → Encrypted Field → Logs de Auditoría
-
-⚠️ **Nota:** Si no ves la opción, asegúrate de tener permisos de administrador y reinstalar el plugin después de actualizar.
-
-### Configuración de permisos
-
-Para acceder a los logs de auditoría, los usuarios necesitan el permiso:
-```json
-{
-  "action": "plugin::encrypted-field.read",
-  "subject": null
-}
-```
-
 ## Uso
 
 ### 1. Agregar campo cifrado a una colección

package/admin/src/components/Input.jsx

@@ -34,63 +34,45 @@ const Input = (props) => {
   };
 
   const handleCopy = async () => {
-    if (value) {
-      try {
-        await navigator.clipboard.writeText(value);
+    if (!value) return;
 
-        // Registrar auditoría
-        await logAudit('copy', name, value);
-
-        toggleNotification({
-          type: 'success',
-          message: 'Copiado al portapapeles',
-        });
-      } catch (err) {
-        toggleNotification({
-          type: 'danger',
-          message: 'Error al copiar',
-        });
-      }
-    }
-  };
-
-  const toggleVisibility = () => {
-    const newVisibility = !isVisible;
-    setIsVisible(newVisibility);
-
-    // Registrar auditoría cuando se muestra el valor
-    if (newVisibility && value) {
-      logAudit('view', name, value);
-    }
-  };
-
-  const logAudit = async (action, fieldName, fieldValue) => {
     try {
-      const response = await fetch('/encrypted-field/audit-logs/log', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          action,
-          field: fieldName,
-          collection: 'unknown', // Se puede mejorar obteniendo el contexto real
-          entry_id: 'unknown', // Se puede mejorar obteniendo el ID real
-          value: fieldValue.substring(0, 50) + (fieldValue.length > 50 ? '...' : ''), // Solo los primeros 50 caracteres para el log
+      await navigator.clipboard.writeText(value);
+      toggleNotification({
+        type: 'success',
+        message: formatMessage({
+          id: 'encrypted-field.notification.copied',
+          defaultMessage: 'Copiado al portapapeles',
+        }),
+      });
+    } catch (err) {
+      toggleNotification({
+        type: 'danger',
+        message: formatMessage({
+          id: 'encrypted-field.notification.copyError',
+          defaultMessage: 'Error al copiar',
         }),
       });
-
-      if (!response.ok) {
-        console.warn('Failed to log audit event');
-      }
-    } catch (error) {
-      console.warn('Error logging audit event:', error);
     }
   };
 
+  const toggleVisibility = () => {
+    setIsVisible((prev) => !prev);
+  };
+
   const fieldName = name.includes('.') ? name.split('.').pop() : name;
   const label = intlLabel?.id ? formatMessage(intlLabel) : (intlLabel || fieldName);
 
+  const visibilityLabel = formatMessage({
+    id: isVisible ? 'encrypted-field.action.hide' : 'encrypted-field.action.show',
+    defaultMessage: isVisible ? 'Ocultar' : 'Mostrar',
+  });
+
+  const copyLabel = formatMessage({
+    id: 'encrypted-field.action.copy',
+    defaultMessage: 'Copiar',
+  });
+
   return (
     <Field.Root
       name={name}
@@ -117,11 +99,11 @@ const Input = (props) => {
           top: '50%',
           transform: 'translateY(-50%)',
           display: 'flex',
-          gap: '4px'
+          gap: '4px',
         }}>
           <IconButton
             onClick={toggleVisibility}
-            label={isVisible ? 'Ocultar' : 'Mostrar'}
+            label={visibilityLabel}
             disabled={disabled}
             variant="ghost"
           >
@@ -129,7 +111,7 @@ const Input = (props) => {
           </IconButton>
           <IconButton
             onClick={handleCopy}
-            label="Copiar"
+            label={copyLabel}
             disabled={disabled || !value}
             variant="ghost"
           >

package/admin/src/index.js

@@ -100,47 +100,18 @@ export default {
         ],
       },
     });
-
-    // Agregar página de auditoría al menú - Strapi 5 approach
-    app.addMenuLink({
-      to: '/plugins/encrypted-field/audit-logs',
-      icon: 'chartLine',
-      intlLabel: {
-        id: 'encrypted-field.menu.audit-logs',
-        defaultMessage: 'Logs de Auditoría',
-      },
-      Component: async () => {
-        const component = await import('./pages/AuditLogs');
-        return component.default;
-      },
-      permissions: [
-        {
-          action: 'plugin::encrypted-field.read',
-          subject: null,
-        },
-      ],
-    });
   },
 
   async registerTrads({ locales }) {
-    const importedTrads = await Promise.all(
-      locales.map((locale) => {
-        return import(`./translations/${locale}.json`)
-          .then(({ default: data }) => {
-            return {
-              data,
-              locale,
-            };
-          })
-          .catch(() => {
-            return {
-              data: {},
-              locale,
-            };
-          });
+    return Promise.all(
+      locales.map(async (locale) => {
+        try {
+          const { default: data } = await import(`./translations/${locale}.json`);
+          return { data, locale };
+        } catch {
+          return { data: {}, locale };
+        }
       })
     );
-
-    return Promise.resolve(importedTrads);
   },
 };

package/admin/src/translations/en.json

@@ -13,5 +13,10 @@
   "encrypted-field.options.minLength.description": "Minimum number of characters required",
   "encrypted-field.options.advanced.regex": "Validation",
   "encrypted-field.options.regex.label": "RegEx pattern",
-  "encrypted-field.options.regex.description": "Validation pattern before encryption"
-}
+  "encrypted-field.options.regex.description": "Validation pattern before encryption",
+  "encrypted-field.notification.copied": "Copied to clipboard",
+  "encrypted-field.notification.copyError": "Error copying to clipboard",
+  "encrypted-field.action.show": "Show",
+  "encrypted-field.action.hide": "Hide",
+  "encrypted-field.action.copy": "Copy"
+}

package/admin/src/translations/es.json

@@ -13,5 +13,10 @@
   "encrypted-field.options.minLength.description": "Número mínimo de caracteres requeridos",
   "encrypted-field.options.advanced.regex": "Validación",
   "encrypted-field.options.regex.label": "RegEx pattern",
-  "encrypted-field.options.regex.description": "Patrón de validación antes de cifrar"
-}
+  "encrypted-field.options.regex.description": "Patrón de validación antes de cifrar",
+  "encrypted-field.notification.copied": "Copiado al portapapeles",
+  "encrypted-field.notification.copyError": "Error al copiar al portapapeles",
+  "encrypted-field.action.show": "Mostrar",
+  "encrypted-field.action.hide": "Ocultar",
+  "encrypted-field.action.copy": "Copiar"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@growy/strapi-plugin-encrypted-field",
-  "version": "2.1.9",
+  "version": "2.3.0",
   "description": "Campo personalizado de texto cifrado para Strapi",
   "strapi": {
     "name": "encrypted-field",
@@ -10,7 +10,9 @@
   },
   "dependencies": {},
   "peerDependencies": {
-    "@strapi/strapi": "^5.0.0"
+    "@strapi/strapi": "^5.0.0",
+    "@strapi/design-system": "^2.0.0",
+    "react": "^18.0.0"
   },
   "main": "server/index.js",
   "exports": {
@@ -53,4 +55,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/server/bootstrap.js

@@ -1,117 +1,79 @@
 const { encrypt, decrypt, validateValue, isEncryptedField } = require('./utils/crypto');
 
+function processEncryption(event, strapi) {
+  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;
+    if (!Object.prototype.hasOwnProperty.call(data, key)) continue;
+
+    const value = data[key];
+    if (value === null || value === undefined || value === '') continue;
+
+    const validation = validateValue(value, attribute);
+    if (!validation.valid) {
+      throw new Error(`Validación fallida para el campo "${key}": ${validation.error}`);
+    }
+
+    data[key] = encrypt(value, strapi);
+  }
+}
+
+function processDecryption(result, event, strapi) {
+  if (!result) return;
+  if (!event.model?.uid) return;
+
+  const currentModel = strapi.getModel(event.model.uid);
+  if (!currentModel?.attributes) return;
+
+  for (const [key, attribute] of Object.entries(currentModel.attributes)) {
+    if (!isEncryptedField(attribute)) continue;
+    if (!Object.prototype.hasOwnProperty.call(result, key)) continue;
+
+    const value = result[key];
+    if (typeof value === 'string' && value) {
+      result[key] = decrypt(value, strapi);
+    }
+  }
+}
+
 module.exports = ({ strapi }) => {
-  
-  
-  const contentTypes = Object.values(strapi.contentTypes);
-  const components = Object.values(strapi.components);
-  const allModels = [...contentTypes, ...components];
-  
+  const allModels = [
+    ...Object.values(strapi.contentTypes),
+    ...Object.values(strapi.components),
+  ];
+
   allModels.forEach((model) => {
     const attributes = model.attributes || {};
-    
-    const encryptedFields = Object.entries(attributes)
-      .filter(([key, attr]) => isEncryptedField(attr))
-      .map(([key]) => key);
-    
-    if (encryptedFields.length === 0) return;
+    const hasEncryptedFields = Object.values(attributes).some(isEncryptedField);
 
-    const uid = model.uid;
+    if (!hasEncryptedFields) return;
 
-  
     strapi.db.lifecycles.subscribe({
-      models: [uid],
-      
+      models: [model.uid],
+
       async beforeCreate(event) {
-        const { data } = event.params;
-        
-        if (!event.model?.uid) return;
-        
-        const currentModel = strapi.getModel(event.model.uid);
-        
-        if (!currentModel?.attributes) return;
-        
-        for (const [key, attribute] of Object.entries(currentModel.attributes)) {
-          if (!isEncryptedField(attribute)) continue;
-          
-          if (Object.prototype.hasOwnProperty.call(data, key)) {
-            const value = data[key];
-            
-            if (value === null || value === undefined || value === '') continue;
-            
-            const validation = validateValue(value, attribute);
-            if (!validation.valid) {
-              throw new Error(`Validación fallida para el campo "${key}": ${validation.error}`);
-            }
-            
-            data[key] = encrypt(value, strapi);
-          }
-        }
+        processEncryption(event, strapi);
       },
 
       async beforeUpdate(event) {
-        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;
-          if (Object.prototype.hasOwnProperty.call(data, key)) {
-            const value = data[key];
-            if (value === null || value === undefined || value === '') continue;
-            
-            const validation = validateValue(value, attribute);
-            if (!validation.valid) {
-              throw new Error(`Validación fallida para el campo "${key}": ${validation.error}`);
-            }
-            
-            data[key] = encrypt(value, strapi);
-          }
-        }
+        processEncryption(event, strapi);
       },
 
       async afterFindOne(event) {
-        const { result } = event;
-        if (!result) return;
-        if (!event.model?.uid) return;
-        
-        const currentModel = strapi.getModel(event.model.uid);
-        
-        if (!currentModel?.attributes) return;
-        
-        for (const [key, attribute] of Object.entries(currentModel.attributes)) {
-          if (!isEncryptedField(attribute)) continue;
-          if (Object.prototype.hasOwnProperty.call(result, key)) {
-            const value = result[key];
-            if (typeof value === 'string' && value) {
-              result[key] = decrypt(value, strapi);
-            }
-          }
-        }
+        processDecryption(event.result, event, strapi);
       },
 
       async afterFindMany(event) {
         const { result } = event;
         if (!result || !Array.isArray(result)) return;
-        if (!event.model?.uid) return;
-        
-        const currentModel = strapi.getModel(event.model.uid);
-        
-        if (!currentModel?.attributes) return;
-        
         for (const item of result) {
-          for (const [key, attribute] of Object.entries(currentModel.attributes)) {
-            if (!isEncryptedField(attribute)) continue;
-            if (Object.prototype.hasOwnProperty.call(item, key)) {
-              const value = item[key];
-              if (typeof value === 'string' && value) {
-                item[key] = decrypt(value, strapi);
-              }
-            }
-          }
+          processDecryption(item, event, strapi);
         }
       },
     });

package/server/index.js

@@ -1,16 +1,14 @@
 const register = require('./register');
 const bootstrap = require('./bootstrap');
 const decrypt = require('./middlewares/decrypt');
-const auditLogController = require('./controllers/audit-log');
-const auditLogRoutes = require('./routes/audit-log');
 
 module.exports = {
   register,
   bootstrap,
-  controllers: {
-    'audit-log': auditLogController,
+  config: {
+    default: {},
+    validator: () => { },
   },
-  routes: auditLogRoutes,
   middlewares: {
     decrypt,
   },

package/server/middlewares/decrypt.js

@@ -1,38 +1,49 @@
 const { decrypt, isEncryptedField } = require('../utils/crypto');
 
+function resolveModelUidFromPath(ctx, strapi) {
+  const path = ctx.request?.path || '';
+  const match = path.match(/^\/api\/([^/]+)/);
+  if (!match) return null;
+
+  const slug = match[1];
+  const contentTypes = Object.values(strapi.contentTypes);
+
+  const ct = contentTypes.find((ct) => {
+    const info = ct.info || {};
+    return info.pluralName === slug || info.singularName === slug;
+  });
+
+  return ct?.uid || null;
+}
+
 module.exports = (config, { strapi }) => {
   return async (ctx, next) => {
     await next();
 
     if (!ctx.body) return;
 
-    
+    const rootModelUid = resolveModelUidFromPath(ctx, strapi);
+
     const decryptRecursive = (obj, modelUid = null) => {
       if (!obj || typeof obj !== 'object') return;
 
-    
       if (Array.isArray(obj)) {
-        obj.forEach(item => decryptRecursive(item, modelUid));
+        obj.forEach((item) => decryptRecursive(item, modelUid));
         return;
       }
 
-      
       let currentModelUid = modelUid;
       if (obj.__component) {
         currentModelUid = obj.__component;
       }
 
-      
       let model = null;
       if (currentModelUid) {
         try {
           model = strapi.getModel(currentModelUid) || strapi.components[currentModelUid];
-        } catch (e) {
-          
-        }
+        } catch (e) { }
       }
 
-      
       if (model?.attributes) {
         for (const [key, attribute] of Object.entries(model.attributes)) {
           if (isEncryptedField(attribute) && obj[key] && typeof obj[key] === 'string') {
@@ -45,7 +56,6 @@ module.exports = (config, { strapi }) => {
         }
       }
 
-      
       for (const value of Object.values(obj)) {
         if (value && typeof value === 'object') {
           decryptRecursive(value, currentModelUid);
@@ -53,12 +63,10 @@ module.exports = (config, { strapi }) => {
       }
     };
 
-    
     if (ctx.body.data) {
-      decryptRecursive(ctx.body.data);
+      decryptRecursive(ctx.body.data, rootModelUid);
     } else {
-      
-      decryptRecursive(ctx.body);
+      decryptRecursive(ctx.body, rootModelUid);
     }
   };
 };

package/server/register.js

@@ -7,5 +7,9 @@ module.exports = ({ strapi }) => {
     name: 'encrypted-text',
     plugin: 'encrypted-field',
     type: 'string',
+    inputSize: {
+      default: 6,
+      isResizable: true,
+    },
   });
 };

package/server/utils/crypto.js

@@ -5,9 +5,12 @@ const IV_LENGTH = 12;
 const AUTH_TAG_LENGTH = 16;
 const KEY_LENGTH = 32;
 
+let _cachedKey = null;
+let _cachedKeySource = null;
+
 function getEncryptionKey(strapi) {
   const key = process.env.ENCRYPTION_KEY || strapi?.config?.get('plugin.encrypted-field.encryptionKey');
-  
+
   if (!key) {
     const errorMsg = '⚠️  ENCRYPTION_KEY no configurada. Debe establecer una clave de 64 caracteres hexadecimales en las variables de entorno o configuración de Strapi.';
     if (strapi?.log?.error) {
@@ -15,33 +18,39 @@ function getEncryptionKey(strapi) {
     }
     throw new Error(errorMsg);
   }
-  
+
+  if (_cachedKey && _cachedKeySource === key) {
+    return _cachedKey;
+  }
+
   if (typeof key !== 'string' || key.length !== 64) {
     throw new Error(`ENCRYPTION_KEY debe tener exactamente 64 caracteres hexadecimales (32 bytes). Actual: ${key?.length || 0}`);
   }
-  
+
   if (!/^[0-9a-fA-F]{64}$/.test(key)) {
     throw new Error('ENCRYPTION_KEY debe contener solo caracteres hexadecimales (0-9, a-f, A-F)');
   }
-  
-  return Buffer.from(key, 'hex');
+
+  _cachedKey = Buffer.from(key, 'hex');
+  _cachedKeySource = key;
+  return _cachedKey;
 }
 
 function encrypt(text, strapi) {
   if (typeof text !== 'string') return text;
-  
+
   if (text === '') return text;
 
   try {
     const ENCRYPTION_KEY = getEncryptionKey(strapi);
     const iv = crypto.randomBytes(IV_LENGTH);
     const cipher = crypto.createCipheriv(ALGORITHM, ENCRYPTION_KEY, iv);
-    
+
     let encrypted = cipher.update(text, 'utf8', 'hex');
     encrypted += cipher.final('hex');
-    
+
     const authTag = cipher.getAuthTag();
-    
+
     return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
   } catch (error) {
     if (strapi?.log?.error) {
@@ -53,29 +62,29 @@ function encrypt(text, strapi) {
 
 function decrypt(encryptedText, strapi) {
   if (!encryptedText || typeof encryptedText !== 'string') return encryptedText;
-  
+
   const parts = encryptedText.split(':');
   if (parts.length !== 3) {
     return encryptedText;
   }
-  
+
   try {
     const [ivHex, authTagHex, encrypted] = parts;
-    
+
     if (ivHex.length !== IV_LENGTH * 2 || authTagHex.length !== AUTH_TAG_LENGTH * 2) {
       return encryptedText;
     }
-    
+
     const ENCRYPTION_KEY = getEncryptionKey(strapi);
     const iv = Buffer.from(ivHex, 'hex');
     const authTag = Buffer.from(authTagHex, 'hex');
-    
+
     const decipher = crypto.createDecipheriv(ALGORITHM, ENCRYPTION_KEY, iv);
     decipher.setAuthTag(authTag);
-    
+
     let decrypted = decipher.update(encrypted, 'hex', 'utf8');
     decrypted += decipher.final('utf8');
-    
+
     return decrypted;
   } catch (error) {
     if (strapi?.log?.debug) {
@@ -91,9 +100,9 @@ function validateValue(value, attribute) {
   }
 
   if (typeof value !== 'string') {
-    return { 
-      valid: false, 
-      error: 'El valor debe ser una cadena de texto' 
+    return {
+      valid: false,
+      error: 'El valor debe ser una cadena de texto'
     };
   }
 
@@ -101,30 +110,30 @@ function validateValue(value, attribute) {
     try {
       const regex = new RegExp(attribute.regex);
       if (!regex.test(value)) {
-        return { 
-          valid: false, 
-          error: `El valor no cumple con el patrón de validación: ${attribute.regex}` 
+        return {
+          valid: false,
+          error: `El valor no cumple con el patrón de validación: ${attribute.regex}`
         };
       }
     } catch (error) {
-      return { 
-        valid: false, 
-        error: `Patrón regex inválido: ${error.message}` 
+      return {
+        valid: false,
+        error: `Patrón regex inválido: ${error.message}`
       };
     }
   }
 
   if (attribute.maxLength && value.length > attribute.maxLength) {
-    return { 
-      valid: false, 
-      error: `El valor excede la longitud máxima de ${attribute.maxLength} caracteres` 
+    return {
+      valid: false,
+      error: `El valor excede la longitud máxima de ${attribute.maxLength} caracteres`
     };
   }
 
   if (attribute.minLength && value.length < attribute.minLength) {
-    return { 
-      valid: false, 
-      error: `El valor debe tener al menos ${attribute.minLength} caracteres` 
+    return {
+      valid: false,
+      error: `El valor debe tener al menos ${attribute.minLength} caracteres`
     };
   }
 

package/admin/src/pages/AuditLogs.jsx

@@ -1,123 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Box, Typography, Table, Pagination, Badge } from '@strapi/design-system';
-import { useNotification } from '@strapi/strapi/admin';
-
-const AuditLogs = () => {
-  const [logs, setLogs] = useState([]);
-  const [loading, setLoading] = useState(true);
-  const [pagination, setPagination] = useState({ page: 1, pageSize: 25, total: 0 });
-  const { toggleNotification } = useNotification();
-
-  const fetchLogs = async (page = 1) => {
-    try {
-      setLoading(true);
-      const response = await fetch(`/encrypted-field/audit-logs?page=${page}&pageSize=${pagination.pageSize}`);
-
-      if (response.ok) {
-        const data = await response.json();
-        setLogs(data.data || []);
-        setPagination(data.meta.pagination);
-      } else {
-        toggleNotification({
-          type: 'danger',
-          message: 'Error al cargar logs de auditoría',
-        });
-      }
-    } catch (error) {
-      console.error('Error fetching audit logs:', error);
-      toggleNotification({
-        type: 'danger',
-        message: 'Error al cargar logs de auditoría',
-      });
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  useEffect(() => {
-    fetchLogs(pagination.page);
-  }, [pagination.page]);
-
-  const handlePageChange = (page) => {
-    setPagination(prev => ({ ...prev, page }));
-  };
-
-  const getBadgeColor = (action) => {
-    switch (action) {
-      case 'view':
-        return 'secondary';
-      case 'copy':
-        return 'warning';
-      case 'decrypt':
-        return 'danger';
-      default:
-        return 'neutral';
-    }
-  };
-
-  const formatTimestamp = (timestamp) => {
-    return new Date(timestamp).toLocaleString('es-ES', {
-      year: 'numeric',
-      month: 'short',
-      day: 'numeric',
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit',
-    });
-  };
-
-  const tableHeaders = [
-    { name: 'timestamp', label: 'Fecha/Hora' },
-    { name: 'user', label: 'Usuario' },
-    { name: 'action', label: 'Acción' },
-    { name: 'field', label: 'Campo' },
-    { name: 'collection', label: 'Colección' },
-    { name: 'entry_id', label: 'ID de entrada' },
-  ];
-
-  return (
-    <Box padding={8}>
-      <Box paddingBottom={4}>
-        <Typography variant="alpha">Logs de Auditoría - Campos Cifrados</Typography>
-        <Typography variant="epsilon" textColor="neutral600">
-          Registro de acciones realizadas sobre campos cifrados
-        </Typography>
-      </Box>
-
-      {loading ? (
-        <Box>Cargando...</Box>
-      ) : (
-        <>
-          <Table
-            headers={tableHeaders}
-            rows={logs.map(log => ({
-              timestamp: formatTimestamp(log.timestamp),
-              user: log.user,
-              action: (
-                <Badge color={getBadgeColor(log.action)}>
-                  {log.action === 'view' && 'Vista'}
-                  {log.action === 'copy' && 'Copiado'}
-                  {log.action === 'decrypt' && 'Descifrado'}
-                </Badge>
-              ),
-              field: log.field,
-              collection: log.collection,
-              entry_id: log.entry_id,
-            }))}
-          />
-          {pagination.total > pagination.pageSize && (
-            <Box paddingTop={4}>
-              <Pagination
-                activePage={pagination.page}
-                pageCount={pagination.pageCount}
-                onPageChange={handlePageChange}
-              />
-            </Box>
-          )}
-        </>
-      )}
-    </Box>
-  );
-};
-
-export default AuditLogs;

package/server/content-types/audit-log/schema.json

@@ -1,59 +0,0 @@
-{
-  "kind": "collectionType",
-  "collectionName": "audit_logs",
-  "info": {
-    "singularName": "audit-log",
-    "pluralName": "audit-logs",
-    "displayName": "Audit Log",
-    "description": "Registros de auditoría para el plugin de campos cifrados"
-  },
-  "options": {
-    "draftAndPublish": false,
-    "timestamps": true
-  },
-  "pluginOptions": {
-    "content-manager": {
-      "visible": true
-    },
-    "content-type-builder": {
-      "visible": false
-    }
-  },
-  "attributes": {
-    "action": {
-      "type": "enumeration",
-      "enum": [
-        "decrypt",
-        "copy",
-        "view"
-      ],
-      "required": true
-    },
-    "user": {
-      "type": "string",
-      "required": true
-    },
-    "field": {
-      "type": "string",
-      "required": true
-    },
-    "collection": {
-      "type": "string",
-      "required": true
-    },
-    "entry_id": {
-      "type": "string",
-      "required": true
-    },
-    "ip_address": {
-      "type": "string"
-    },
-    "user_agent": {
-      "type": "text"
-    },
-    "timestamp": {
-      "type": "datetime",
-      "default": "now"
-    }
-  }
-}

package/server/controllers/audit-log.js

@@ -1,67 +0,0 @@
-const { createCoreController } = require('@strapi/strapi').factories;
-
-module.exports = createCoreController('plugin::encrypted-field.audit-log', ({ strapi }) => ({
-  async log(ctx) {
-    try {
-      const { action, field, collection, entry_id, ip_address, user_agent } = ctx.request.body;
-
-      // Obtener información del usuario actual
-      const user = ctx.state.user;
-      const userInfo = user ? `${user.firstname || ''} ${user.lastname || ''}`.trim() || user.username || user.email : 'Usuario desconocido';
-
-      // Crear el registro de auditoría
-      const auditLog = await strapi.entityService.create('plugin::encrypted-field.audit-log', {
-        data: {
-          action,
-          user: userInfo,
-          field,
-          collection,
-          entry_id,
-          ip_address: ip_address || ctx.request.ip,
-          user_agent: user_agent || ctx.request.header['user-agent'],
-          timestamp: new Date()
-        }
-      });
-
-      ctx.send({
-        success: true,
-        data: auditLog
-      });
-
-    } catch (error) {
-      strapi.log.error('Error creating audit log:', error);
-      ctx.badRequest('Error al registrar auditoría', { error: error.message });
-    }
-  },
-
-  async getLogs(ctx) {
-    try {
-      const { page = 1, pageSize = 25, sort = 'timestamp:desc' } = ctx.query;
-
-      const logs = await strapi.entityService.findMany('plugin::encrypted-field.audit-log', {
-        start: (page - 1) * pageSize,
-        limit: pageSize,
-        sort: sort,
-        populate: '*'
-      });
-
-      const total = await strapi.entityService.count('plugin::encrypted-field.audit-log');
-
-      ctx.send({
-        data: logs,
-        meta: {
-          pagination: {
-            page: parseInt(page),
-            pageSize: parseInt(pageSize),
-            pageCount: Math.ceil(total / pageSize),
-            total
-          }
-        }
-      });
-
-    } catch (error) {
-      strapi.log.error('Error fetching audit logs:', error);
-      ctx.badRequest('Error al obtener logs de auditoría', { error: error.message });
-    }
-  }
-}));

package/server/routes/audit-log.js

@@ -1,20 +0,0 @@
-module.exports = [
-  {
-    method: 'POST',
-    path: '/audit-logs/log',
-    handler: 'audit-log.log',
-    config: {
-      policies: [],
-      auth: false,
-    }
-  },
-  {
-    method: 'GET',
-    path: '/audit-logs',
-    handler: 'audit-log.getLogs',
-    config: {
-      policies: [],
-      auth: false,
-    }
-  }
-];