test-entity-library-asm 3.9.7 → 3.9.8

package/dist/transformers/jsonEncryptionTransformer.js

@@ -4,7 +4,7 @@ exports.JsonEncryptionTransformer = void 0;
 const crypto = require("crypto");
 const ENCRYPTION_KEY = process.env.SECRET_ENCRYPTION_KEY || "clave-32-bytes-segura";
 const ALGORITHM = "aes-256-cbc";
-// KeyObject de 32 bytes (evita líos de tipos con CipherKey)
+// KeyObject de 32 bytes
 const KEY = crypto.createSecretKey(crypto.createHash("sha256").update(String(ENCRYPTION_KEY)).digest());
 function looksLikeCBC(encoded) {
     // formato: iv:cipherHex
@@ -13,12 +13,10 @@ function looksLikeCBC(encoded) {
 function decryptValue(value) {
     if (typeof value !== "string" || !looksLikeCBC(value))
         return value;
-    var parts = value.split(":");
-    var ivHex = parts[0];
-    var contentHex = parts[1];
-    var iv = Buffer.from(ivHex, "hex");
-    var decipher = crypto.createDecipheriv(ALGORITHM, KEY, iv);
-    var dec = Buffer.concat([
+    const [ivHex, contentHex] = value.split(":");
+    const iv = Buffer.from(ivHex, "hex");
+    const decipher = crypto.createDecipheriv(ALGORITHM, KEY, iv);
+    const dec = Buffer.concat([
         decipher.update(Buffer.from(contentHex, "hex")),
         decipher.final(),
     ]);
@@ -27,45 +25,84 @@ function decryptValue(value) {
 function encryptValue(plain) {
     if (plain === null || plain === undefined)
         return null;
-    var text = String(plain);
-    var iv = crypto.randomBytes(16);
-    var cipher = crypto.createCipheriv(ALGORITHM, KEY, iv);
-    var enc = Buffer.concat([cipher.update(text, "utf8"), cipher.final()]);
+    const text = String(plain);
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv(ALGORITHM, KEY, iv);
+    const enc = Buffer.concat([cipher.update(text, "utf8"), cipher.final()]);
     return iv.toString("hex") + ":" + enc.toString("hex");
 }
-exports.JsonEncryptionTransformer = {
-    to(value) {
-        if (typeof value !== "object" || value === null)
-            return JSON.stringify({});
-        var out = {};
-        for (var k in value) {
-            var v = value[k];
-            // No usamos startsWith (no tipado en ES5)
+/** Recorre profundo y encripta solo claves `encrypted_*` */
+function deepEncrypt(input) {
+    if (input === null || input === undefined)
+        return input;
+    if (Array.isArray(input)) {
+        const arr = [];
+        for (let i = 0; i < input.length; i++) {
+            arr[i] = deepEncrypt(input[i]);
+        }
+        return arr;
+    }
+    if (typeof input === "object") {
+        const out = {};
+        for (const k in input) {
+            const v = input[k];
             if (k.length >= 10 && k.substr(0, 10) === "encrypted_") {
                 out[k] = encryptValue(v);
             }
             else {
-                out[k] = v;
+                out[k] = deepEncrypt(v);
             }
         }
-        return JSON.stringify(out);
+        return out;
+    }
+    // primitivos
+    return input;
+}
+/** Recorre profundo y desencripta solo claves `encrypted_*` */
+function deepDecrypt(input) {
+    if (input === null || input === undefined)
+        return input;
+    if (Array.isArray(input)) {
+        const arr = [];
+        for (let i = 0; i < input.length; i++) {
+            arr[i] = deepDecrypt(input[i]);
+        }
+        return arr;
+    }
+    if (typeof input === "object") {
+        const out = {};
+        for (const k in input) {
+            const v = input[k];
+            if (k.length >= 10 && k.substr(0, 10) === "encrypted_") {
+                try {
+                    out[k] = decryptValue(v);
+                }
+                catch {
+                    out[k] = v; // si está corrupto, lo dejamos como está
+                }
+            }
+            else {
+                out[k] = deepDecrypt(v);
+            }
+        }
+        return out;
+    }
+    // primitivos
+    return input;
+}
+exports.JsonEncryptionTransformer = {
+    to(value) {
+        if (typeof value !== "object" || value === null)
+            return JSON.stringify({});
+        return JSON.stringify(deepEncrypt(value));
     },
     from(dbValue) {
         try {
-            var parsed = JSON.parse(dbValue);
-            for (var k in parsed) {
-                if (k.length >= 10 && k.substr(0, 10) === "encrypted_") {
-                    try {
-                        parsed[k] = decryptValue(parsed[k]);
-                    }
-                    catch {
-                        // si falla, deja el valor original
-                    }
-                }
-            }
-            return parsed;
+            const parsed = JSON.parse(dbValue);
+            return deepDecrypt(parsed);
         }
         catch {
+            // si no es JSON válido, no tumbar todo
             return {};
         }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-entity-library-asm",
-  "version": "3.9.7",
+  "version": "3.9.8",
   "description": "Entidades de ejemplo para una base de datos",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/transformers/jsonEncryptionTransformer.ts

@@ -5,7 +5,7 @@ const ENCRYPTION_KEY =
   process.env.SECRET_ENCRYPTION_KEY || "clave-32-bytes-segura";
 const ALGORITHM = "aes-256-cbc";
 
-// KeyObject de 32 bytes (evita líos de tipos con CipherKey)
+// KeyObject de 32 bytes
 const KEY = crypto.createSecretKey(
   crypto.createHash("sha256").update(String(ENCRYPTION_KEY)).digest()
 );
@@ -17,14 +17,10 @@ function looksLikeCBC(encoded: string) {
 
 function decryptValue(value: any): any {
   if (typeof value !== "string" || !looksLikeCBC(value)) return value;
-
-  var parts = value.split(":");
-  var ivHex = parts[0];
-  var contentHex = parts[1];
-
-  var iv = Buffer.from(ivHex, "hex");
-  var decipher = crypto.createDecipheriv(ALGORITHM, KEY, iv);
-  var dec = Buffer.concat([
+  const [ivHex, contentHex] = value.split(":");
+  const iv = Buffer.from(ivHex, "hex");
+  const decipher = crypto.createDecipheriv(ALGORITHM, KEY, iv);
+  const dec = Buffer.concat([
     decipher.update(Buffer.from(contentHex, "hex")),
     decipher.final(),
   ]);
@@ -33,45 +29,87 @@ function decryptValue(value: any): any {
 
 function encryptValue(plain: any): string | null {
   if (plain === null || plain === undefined) return null;
-  var text = String(plain);
-
-  var iv = crypto.randomBytes(16);
-  var cipher = crypto.createCipheriv(ALGORITHM, KEY, iv);
-  var enc = Buffer.concat([cipher.update(text, "utf8"), cipher.final()]);
+  const text = String(plain);
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv(ALGORITHM, KEY, iv);
+  const enc = Buffer.concat([cipher.update(text, "utf8"), cipher.final()]);
   return iv.toString("hex") + ":" + enc.toString("hex");
 }
 
-export const JsonEncryptionTransformer: ValueTransformer = {
-  to(value: any): string {
-    if (typeof value !== "object" || value === null) return JSON.stringify({});
+/** Recorre profundo y encripta solo claves `encrypted_*` */
+function deepEncrypt(input: any): any {
+  if (input === null || input === undefined) return input;
+
+  if (Array.isArray(input)) {
+    const arr: any[] = [];
+    for (let i = 0; i < input.length; i++) {
+      arr[i] = deepEncrypt(input[i]);
+    }
+    return arr;
+  }
 
-    var out: { [k: string]: any } = {};
-    for (var k in value) {
-      var v = value[k];
-      // No usamos startsWith (no tipado en ES5)
+  if (typeof input === "object") {
+    const out: { [k: string]: any } = {};
+    for (const k in input) {
+      const v = input[k];
       if (k.length >= 10 && k.substr(0, 10) === "encrypted_") {
         out[k] = encryptValue(v);
       } else {
-        out[k] = v;
+        out[k] = deepEncrypt(v);
       }
     }
-    return JSON.stringify(out);
+    return out;
+  }
+
+  // primitivos
+  return input;
+}
+
+/** Recorre profundo y desencripta solo claves `encrypted_*` */
+function deepDecrypt(input: any): any {
+  if (input === null || input === undefined) return input;
+
+  if (Array.isArray(input)) {
+    const arr: any[] = [];
+    for (let i = 0; i < input.length; i++) {
+      arr[i] = deepDecrypt(input[i]);
+    }
+    return arr;
+  }
+
+  if (typeof input === "object") {
+    const out: { [k: string]: any } = {};
+    for (const k in input) {
+      const v = input[k];
+      if (k.length >= 10 && k.substr(0, 10) === "encrypted_") {
+        try {
+          out[k] = decryptValue(v);
+        } catch {
+          out[k] = v; // si está corrupto, lo dejamos como está
+        }
+      } else {
+        out[k] = deepDecrypt(v);
+      }
+    }
+    return out;
+  }
+
+  // primitivos
+  return input;
+}
+
+export const JsonEncryptionTransformer: ValueTransformer = {
+  to(value: any): string {
+    if (typeof value !== "object" || value === null) return JSON.stringify({});
+    return JSON.stringify(deepEncrypt(value));
   },
 
   from(dbValue: string): any {
     try {
-      var parsed = JSON.parse(dbValue);
-      for (var k in parsed) {
-        if (k.length >= 10 && k.substr(0, 10) === "encrypted_") {
-          try {
-            parsed[k] = decryptValue(parsed[k]);
-          } catch {
-            // si falla, deja el valor original
-          }
-        }
-      }
-      return parsed;
+      const parsed = JSON.parse(dbValue);
+      return deepDecrypt(parsed);
     } catch {
+      // si no es JSON válido, no tumbar todo
       return {};
     }
   },