@growy/strapi-plugin-encrypted-field 2.2.1 → 2.3.1

package/README.md

@@ -6,40 +6,41 @@
   <img src="https://img.shields.io/badge/Strapi-v5-blueviolet" alt="Strapi v5" />
 </div>
 
-Plugin oficial de **Growy AI** para Strapi que proporciona un campo personalizado de texto cifrado con AES-256-GCM. Protege información sensible directamente en tu base de datos con cifrado transparente y validación robusta.
+---
 
+### [English](#english-version) | [Español](#versión-en-español)
 
-- ✅ **Campo personalizado** "Texto Cifrado" en el Content-Type Builder
-- ✅ **Cifrado automático** AES-256-GCM al guardar
-- ✅ **Descifrado transparente** al leer (panel y API)
-- ✅ **Validación backend** con soporte para regex y restricciones
-- ✅ **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
-- ✅ **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
-- ✅ **Soporte completo** para componentes anidados y estructuras complejas
+---
 
-## Instalación
+## English Version
 
-### Desde npm
+Official **Growy AI** plugin for Strapi that provide a custom encrypted text field using AES-256-GCM. Protect sensitive information directly in your database with transparent encryption and robust validation.
 
-```bash
-npm install @growy/strapi-plugin-encrypted-field
-```
+### Features
 
-### Desde yarn
+- ✅ **Custom Field** "Encrypted Text" in the Content-Type Builder.
+- ✅ **Automatic Encryption** AES-256-GCM when saving.
+- ✅ **Transparent Decryption** when reading (Admin panel and API).
+- ✅ **Backend Validation** with regex support and length constraints.
+- ✅ **Native Strapi v5 UI** with visibility controls and copy to clipboard.
+- ✅ **Multi-language support (i18n)**: English and Spanish.
+- ✅ **Secure Key Management** with validation and clear error messages.
+- ✅ **Encrypted Data** in database with unique IV and Auth Tag.
+- ✅ **Nested Components support** at any depth.
+
+### Installation
 
 ```bash
+npm install @growy/strapi-plugin-encrypted-field
+# or
 yarn add @growy/strapi-plugin-encrypted-field
 ```
 
-## Configuración
+### Configuration
 
-### 1. Habilitar el plugin
+#### 1. Enable the plugin
 
-Crea o edita `config/plugins.js` o `config/plugins.ts`:
+Create or edit `config/plugins.js` or `config/plugins.ts`:
 
 ```javascript
 module.exports = {
@@ -49,199 +50,111 @@ module.exports = {
 };
 ```
 
-### 2. Configurar la clave de cifrado (REQUERIDO)
+#### 2. Configure Encryption Key (REQUIRED)
 
-#### Opción A: Variable de entorno (recomendado)
-
-Agrega a tu `.env`:
+Add to your `.env`:
 
 ```bash
-ENCRYPTION_KEY=tu_clave_de_64_caracteres_hexadecimales_aqui
+ENCRYPTION_KEY=your_64_character_hex_key_here
 ```
 
-#### Opción B: Archivo de configuración
-
-Edita `config/plugins.js`:
-
-```javascript
-module.exports = ({ env }) => ({
-  'encrypted-field': {
-    enabled: true,
-    config: {
-      encryptionKey: env('ENCRYPTION_KEY'),
-    },
-  },
-});
-```
-
-#### Generar clave segura
-
+Generate a secure key:
 ```bash
 node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
 ```
 
-Esto generará una clave de 64 caracteres hexadecimales (32 bytes).
-
-⚠️ **CRÍTICO - Gestión de claves**:
-- **Guarda la clave de forma segura** (gestor de secretos, variables de entorno cifradas)
-- **Nunca** la incluyas en el control de versiones
-- **Si pierdes la clave**, no podrás descifrar los datos existentes
-- **Usa la misma clave** en todos los entornos que compartan la misma base de datos
-- **Para producción**, considera usar servicios como AWS Secrets Manager, HashiCorp Vault o similar
-
-### 3. Rebuild del admin
-
-```bash
-npm run build
-npm run develop
-```
-
-## Requisitos
-
-- **Strapi**: v5.0.0 o superior
-- **Node.js**: 18.x - 22.x
-- **npm**: 6.0.0 o superior
-
-## Validación de datos
+### Usage
 
-El plugin soporta validación antes del cifrado:
+1. Go to **Content-Type Builder**.
+2. Select a collection or create a new one.
+3. Click on **"Add another field"**.
+4. Select **"Encrypted Text"** (look for the 🔒 icon).
+5. Values are hidden by default in the Admin Panel but can be revealed or copied using the inline buttons.
 
-### Configurar validación regex
-
-1. En el Content-Type Builder, selecciona el campo cifrado
-2. Ve a la pestaña **"Advanced Settings"**
-3. En **"RegEx pattern"**, ingresa tu expresión regular
-4. Guarda los cambios
-
-**Ejemplo**: Para validar formato de API key:
-```regex
-^sk-[a-zA-Z0-9]{32}$
-```
-
-Si el valor no cumple con el patrón, se lanzará un error antes de cifrar.
-
-## Uso
-
-### 1. Agregar campo cifrado a una colección
+---
 
-1. Ve a **Content-Type Builder**
-2. Selecciona una colección o crea una nueva
-3. Click en **"Add another field"**
-4. Busca **"Texto Cifrado"** (con icono 🔒)
-5. Configura el nombre del campo
-6. Guarda y reinicia Strapi
+## Versión en Español
 
-### 2. Usar el campo
+Plugin oficial de **Growy AI** para Strapi que proporciona un campo personalizado de texto cifrado con AES-256-GCM. Protege información sensible directamente en tu base de datos con cifrado transparente y validación robusta.
 
-El campo funciona como un campo de texto normal con características de seguridad adicionales:
+### Características
 
-- **En el panel**: Escribe texto normalmente
-- **Valores ocultos**: Los valores se muestran como `***` por defecto
-- **Botón ojo**: Alterna entre mostrar/ocultar el valor
-- **Botón copiar**: Copia el valor al portapapeles con notificación de confirmación
-- **Placeholder personalizable**: Configura un placeholder desde las opciones del campo
-- **Al guardar**: Se cifra automáticamente
-- **Al leer**: Se descifra automáticamente
-- **En la BD**: Se guarda cifrado con formato `iv:authTag:encrypted`
-- **En componentes**: Funciona igual en componentes anidados de cualquier profundidad
+- ✅ **Campo personalizado** "Texto Cifrado" en el Content-Type Builder.
+- ✅ **Cifrado automático** AES-256-GCM al guardar.
+- ✅ **Descifrado transparente** al leer (panel y API).
+- ✅ **Validación backend** con soporte para regex y restricciones.
+- ✅ **UI Nativa Strapi v5** con controles de visibilidad y copiar al portapapeles.
+- ✅ **Soporte multi-idioma (i18n)**: Inglés y Español.
+- ✅ **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.
+- ✅ **Soporte para componentes anidados** a cualquier profundidad.
 
-### 3. Uso por API
+### Instalación
 
 ```bash
-# Crear con campo cifrado
-curl -X POST http://localhost:1337/api/usuarios \
-  -H "Content-Type: application/json" \
-  -d '{
-    "data": {
-      "nombre": "Juan",
-      "apiKey": "mi-clave-secreta-123"
-    }
-  }'
-
-# Leer (devuelve descifrado)
-curl -X GET http://localhost:1337/api/usuarios/1
-# Response: { "nombre": "Juan", "apiKey": "mi-clave-secreta-123" }
+npm install @growy/strapi-plugin-encrypted-field
+# o
+yarn add @growy/strapi-plugin-encrypted-field
 ```
 
-## Ejemplo de uso
+### Configuración
 
-### Colección "Usuario" con API Key cifrada
+#### 1. Habilitar el plugin
 
-**Schema:**
-```json
-{
-  "nombre": "string",
-  "email": "email",
-  "apiKey": "plugin::encrypted-field.encrypted-text"
-}
-```
-
-**En la BD:**
-```
-apiKey: "a1b2c3d4e5f6....:f9e8d7c6b5a4....:9f8e7d6c5b4a3..."
-```
+Edita `config/plugins.js`:
 
-**En el panel y API:**
-```
-apiKey: "sk-1234567890abcdef"
+```javascript
+module.exports = {
+  'encrypted-field': {
+    enabled: true,
+  },
+};
 ```
 
-## Seguridad y arquitectura
-
-### Especificaciones técnicas
+#### 2. Configurar la clave (REQUERIDO)
 
-- **Algoritmo**: AES-256-GCM (estándar NIST, grado militar)
-- **Tamaño de clave**: 256 bits (32 bytes, 64 caracteres hexadecimales)
-- **IV (Initialization Vector)**: 96 bits (12 bytes) generado aleatoriamente por operación
-- **Auth Tag**: 128 bits (16 bytes) para verificación de integridad
-- **Formato almacenado**: `iv:authTag:encryptedData` (todos en hexadecimal)
+Agrega a tu `.env`:
 
-### Características de seguridad
+```bash
+ENCRYPTION_KEY=tu_clave_de_64_caracteres_hexadecimales_aqui
+```
 
-- ✅ **Cifrado autenticado**: GCM proporciona confidencialidad e integridad
-- ✅ **IV único**: Cada operación de cifrado genera un IV aleatorio
-- ✅ **Resistencia a manipulación**: Auth Tag detecta cualquier modificación
-- ✅ **Validación de entrada**: Soporte para regex y restricciones personalizadas
-- ✅ **Manejo de errores seguro**: Logs controlados sin exponer datos sensibles
+### Uso
 
-### Mejores prácticas
+1. Ve a **Content-Type Builder**.
+2. Selecciona una colección.
+3. Click en **"Add another field"**.
+4. Selecciona **"Texto Cifrado"** (icono 🔒).
+5. Los valores están ocultos por defecto en el panel pero pueden mostrarse o copiarse con los botones integrados.
 
-1. **Rotación de claves**: Planifica un proceso de rotación periódica
-2. **Separación de entornos**: Usa claves diferentes para dev/staging/prod
-3. **Auditoría**: Monitorea logs de errores de cifrado/descifrado
-4. **Backup de claves**: Mantén copias seguras de las claves en múltiples ubicaciones
-5. **Campos privados**: Marca campos sensibles como "privados" para excluirlos de la API pública
+### Seguridad y Especificaciones
 
-## Casos de uso
+- **Algoritmo**: AES-256-GCM.
+- **IV (Initialization Vector)**: 96 bits generado aleatoriamente por operación.
+- **Auth Tag**: 128 bits para verificación de integridad.
+- **Formato almacenado**: `iv:authTag:encryptedData`.
 
-- 🔑 API Keys de terceros
-- 🔐 Tokens de acceso
-- 🔒 Secretos de webhooks
-- 💳 Información sensible
-- 📧 Credenciales SMTP
-- 🔑 Contraseñas de aplicaciones
+### Limitaciones
 
-## Limitaciones conocidas
+- ❌ **Búsqueda**: No se puede buscar por campos cifrados.
+- ❌ **Ordenamiento**: No se puede ordenar por campos cifrados.
+- ❌ **Filtros**: No se pueden aplicar filtros directos sobre datos cifrados.
 
-- ❌ **Búsqueda**: No se puede buscar por campos cifrados (datos cifrados en BD)
-- ❌ **Ordenamiento**: No se puede ordenar por campos cifrados
-- ❌ **Filtros**: No se pueden aplicar filtros directos sobre campos cifrados
-- ⚠️ **Rendimiento**: El cifrado/descifrado añade overhead mínimo (~1-2ms por operación)
-- ⚠️ **Sincronización de claves**: Todos los entornos que compartan BD deben usar la misma clave
+---
 
-## Licencia
+## License / Licencia
 
 MIT © 2025 Growy AI
 
-## Desarrollado por
+## Credits / Créditos
 
 **Growy AI** - Soluciones de IA y automatización empresarial
 
-**Autor principal**: Zahir El isaac
+**Main Author / Autor principal**: Zahir El isaac
 
 ---
 
 <div align="center">
-  <p>Si este plugin te resulta útil, considera darle una ⭐ en GitHub</p>
-  <p>Hecho con ❤️ por el equipo de Growy AI</p>
+  <p>If this plugin is useful to you, consider giving it a ⭐ on GitHub / Si este plugin te resulta útil, considera darle una ⭐ en GitHub</p>
+  <p>Made with ❤️ by Growy AI Team</p>
 </div>

package/admin/src/components/Input.jsx

@@ -34,29 +34,45 @@ const Input = (props) => {
   };
 
   const handleCopy = async () => {
-    if (value) {
-      try {
-        await navigator.clipboard.writeText(value);
-        toggleNotification({
-          type: 'success',
-          message: 'Copiado al portapapeles',
-        });
-      } catch (err) {
-        toggleNotification({
-          type: 'danger',
-          message: 'Error al copiar',
-        });
-      }
+    if (!value) return;
+
+    try {
+      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',
+        }),
+      });
     }
   };
 
   const toggleVisibility = () => {
-    setIsVisible(!isVisible);
+    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}
@@ -77,17 +93,17 @@ const Input = (props) => {
           disabled={disabled}
           style={{ paddingRight: '80px' }}
         />
-        <div style={{ 
-          position: 'absolute', 
-          right: '8px', 
-          top: '50%', 
+        <div style={{
+          position: 'absolute',
+          right: '8px',
+          top: '50%',
           transform: 'translateY(-50%)',
           display: 'flex',
-          gap: '4px'
+          gap: '4px',
         }}>
           <IconButton
             onClick={toggleVisibility}
-            label={isVisible ? 'Ocultar' : 'Mostrar'}
+            label={visibilityLabel}
             disabled={disabled}
             variant="ghost"
           >
@@ -95,7 +111,7 @@ const Input = (props) => {
           </IconButton>
           <IconButton
             onClick={handleCopy}
-            label="Copiar"
+            label={copyLabel}
             disabled={disabled || !value}
             variant="ghost"
           >

package/admin/src/index.js

@@ -103,24 +103,15 @@ export default {
   },
 
   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.2.1",
+  "version": "2.3.1",
   "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

@@ -5,6 +5,10 @@ const decrypt = require('./middlewares/decrypt');
 module.exports = {
   register,
   bootstrap,
+  config: {
+    default: {},
+    validator: () => { },
+  },
   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

@@ -1,11 +1,15 @@
 module.exports = ({ strapi }) => {
   const decryptMiddleware = require('./middlewares/decrypt');
-  
+
   strapi.server.use(decryptMiddleware({}, { strapi }));
-  
+
   strapi.customFields.register({
     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`
     };
   }