@growy/strapi-plugin-encrypted-field 1.5.0 → 1.7.0

package/package.json

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

package/server/bootstrap.js

@@ -1,8 +1,23 @@
 const { encrypt, decrypt, validateValue, isEncryptedField } = require('./utils/crypto');
 
 module.exports = ({ strapi }) => {
-  strapi.db.lifecycles.subscribe({
-    async beforeCreate(event) {
+  // Registrar lifecycles para cada content type que tenga campos cifrados
+  const models = Object.values(strapi.contentTypes);
+  
+  models.forEach((model) => {
+    const hasEncryptedFields = Object.values(model.attributes || {}).some(isEncryptedField);
+    
+    if (!hasEncryptedFields) return;
+
+    const uid = model.uid;
+    
+    strapi.log.info(`Registrando lifecycles de cifrado para ${uid}`);
+
+    // Registrar lifecycle específico para este content type
+    strapi.db.lifecycles.subscribe({
+      models: [uid],
+      
+      async beforeCreate(event) {
       if (!event.model?.uid) return;
       
       const { data } = event.params;
@@ -105,6 +120,7 @@ module.exports = ({ strapi }) => {
           }
         }
       }
-    },
+      },
+    });
   });
 };

package/server/index.js

@@ -1,7 +1,11 @@
 const register = require('./register');
 const bootstrap = require('./bootstrap');
+const decrypt = require('./middlewares/decrypt');
 
 module.exports = {
   register,
   bootstrap,
+  middlewares: {
+    decrypt,
+  },
 };

package/server/middlewares/decrypt.js

@@ -0,0 +1,43 @@
+const { decrypt, isEncryptedField } = require('../utils/crypto');
+
+module.exports = (config, { strapi }) => {
+  return async (ctx, next) => {
+    await next();
+
+    if (!ctx.body || !ctx.body.data) return;
+
+    const decryptData = (data) => {
+      if (!data || typeof data !== 'object') return;
+
+      const contentType = ctx.params?.model || ctx.state?.route?.info?.type;
+      if (!contentType) return;
+
+      let model;
+      try {
+        model = strapi.getModel(contentType);
+      } catch (e) {
+        return;
+      }
+
+      if (!model?.attributes) return;
+
+      for (const [key, attribute] of Object.entries(model.attributes)) {
+        if (!isEncryptedField(attribute)) continue;
+        
+        if (data[key] && typeof data[key] === 'string') {
+          try {
+            data[key] = decrypt(data[key], strapi);
+          } catch (error) {
+            strapi.log.error(`Error descifrando campo ${key}: ${error.message}`);
+          }
+        }
+      }
+    };
+
+    if (Array.isArray(ctx.body.data)) {
+      ctx.body.data.forEach(decryptData);
+    } else {
+      decryptData(ctx.body.data);
+    }
+  };
+};