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

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.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

@@ -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`
     };
   }