jerkjs 2.1.2 → 2.1.3

package/CHANGELOG.md

@@ -1,9 +1,11 @@
 # CHANGELOG
 
-## v2.1.2 - 17 de enero de 2026
+## v2.1.3 - 17 de enero de 2026
 
 ### Nuevas características
 
+- **Sistema de hooks/filters en middleware de compresión**: Se ha integrado completamente el sistema de hooks y filters en el middleware de compresión, permitiendo extender y personalizar el comportamiento de compresión en múltiples puntos del proceso (antes/después de la compresión, modificación de chunks, manejo de encabezados, etc.)
+
 - **Optimización del procesamiento del body request**: Se ha implementado una nueva técnica para procesar el cuerpo de las solicitudes usando arrays de chunks en lugar de concatenación de strings, lo que reduce significativamente el uso de memoria y mejora el rendimiento para solicitudes grandes (reducción del 50-70% en tiempo de procesamiento).
 
 - **Cacheo de expresiones regulares para rutas parametrizadas**: Se ha añadido un sistema de cache para las expresiones regulares compiladas de rutas parametrizadas, evitando la recompilación repetida y mejorando el rendimiento del enrutamiento (reducción del 10-20% en tiempo de routing).

package/README.md

@@ -1,4 +1,4 @@
-# JERK Framework v2.1.2
+# JERK Framework v2.1.3
 
 ![JERK Framework Logo](jerk.jpg)
 

package/lib/middleware/compressor.js

@@ -1,7 +1,7 @@
 /**
  * Middleware de compresión para el framework JERK
  * Implementación del componente middleware/compressor.js
- * JERK Framework v2.1.1 - Con optimizaciones de eficiencia y corrección de errores
+ * JERK Framework v2.1.3 - Con optimizaciones de eficiencia, corrección de errores y sistema de hooks/filters
  */
 
 const zlib = require('zlib');
@@ -14,12 +14,14 @@ class Compressor {
    * @param {number} options.threshold - Tamaño mínimo en bytes para comprimir
    * @param {Object} options.gzipOptions - Opciones para compresión gzip
    * @param {Object} options.deflateOptions - Opciones para compresión deflate
+   * @param {Object} options.hooks - Sistema de hooks para extensibilidad
    */
   constructor(options = {}) {
     this.encodings = options.encodings || ['gzip', 'deflate'];
     this.threshold = options.threshold || 1024; // 1KB por defecto
     this.gzipOptions = options.gzipOptions || {};
     this.deflateOptions = options.deflateOptions || {};
+    this.hooks = options.hooks || null; // Sistema de hooks opcional para extensibilidad
   }
 
   /**
@@ -37,7 +39,7 @@ class Compressor {
 
       // Determinar el método de compresión preferido
       let compressionMethod = null;
-      
+
       if (acceptEncoding.includes('gzip')) {
         compressionMethod = 'gzip';
       } else if (acceptEncoding.includes('deflate')) {
@@ -50,6 +52,11 @@ class Compressor {
         return;
       }
 
+      // Permitir a los hooks modificar el método de compresión
+      if (this.hooks && this.hooks.applyFilters) {
+        compressionMethod = this.hooks.applyFilters('compressor_method', compressionMethod, req, res);
+      }
+
       // Guardar el método original de res.end
       const originalEnd = res.end;
       const originalWriteHead = res.writeHead;
@@ -59,6 +66,10 @@ class Compressor {
 
       // Sobrescribir res.write para capturar los chunks
       res.write = (chunk, encoding) => {
+        // Permitir a los hooks interceptar los chunks antes de almacenarlos
+        if (this.hooks && this.hooks.applyFilters) {
+          chunk = this.hooks.applyFilters('compressor_chunk_before_store', chunk, req, res, encoding);
+        }
         responseChunks.push(chunk);
       };
 
@@ -66,16 +77,40 @@ class Compressor {
       res.end = (chunk, encoding) => {
         // Añadir el chunk final a los chunks si existe
         if (chunk) {
+          // Permitir a los hooks interceptar el chunk final antes de almacenarlo
+          if (this.hooks && this.hooks.applyFilters) {
+            chunk = this.hooks.applyFilters('compressor_final_chunk_before_store', chunk, req, res, encoding);
+          }
           responseChunks.push(chunk);
         }
 
         // Concatenar todos los chunks una sola vez
-        const responseBody = Buffer.concat(responseChunks.map(c =>
+        let responseBody = Buffer.concat(responseChunks.map(c =>
           typeof c === 'string' ? Buffer.from(c, encoding) : c
         )).toString();
 
+        // Permitir a los hooks modificar el cuerpo de la respuesta antes de evaluar el umbral
+        if (this.hooks && this.hooks.applyFilters) {
+          responseBody = this.hooks.applyFilters('compressor_response_body_before_threshold_check', responseBody, req, res);
+        }
+
         // Si el cuerpo es menor que el umbral, enviar sin comprimir
         if (Buffer.byteLength(responseBody) < this.threshold) {
+          // Permitir a los hooks modificar el comportamiento cuando no se comprime
+          if (this.hooks && this.hooks.applyFilters) {
+            const shouldCompress = this.hooks.applyFilters('compressor_should_compress', false, responseBody, req, res, this.threshold);
+            if (shouldCompress) {
+              // Si un hook determina que debería comprimirse, proseguir con la compresión
+              this._performCompression(req, res, originalEnd, originalWriteHead, responseBody, compressionMethod);
+              return;
+            }
+          }
+
+          // Permitir a los hooks modificar el comportamiento cuando no se comprime
+          if (this.hooks && this.hooks.doAction) {
+            this.hooks.doAction('compressor_skip_compression', req, res, responseBody, this.threshold);
+          }
+
           // Solo establecer encabezados si no se han enviado aún
           if (!res.headersSent) {
             res.removeHeader('Content-Encoding'); // Asegurar que no haya encabezado de codificación
@@ -85,6 +120,11 @@ class Compressor {
           return;
         }
 
+        // Permitir a los hooks modificar el comportamiento cuando se va a comprimir
+        if (this.hooks && this.hooks.doAction) {
+          this.hooks.doAction('compressor_before_compression', req, res, responseBody, compressionMethod);
+        }
+
         // Aplicar compresión según el método seleccionado
         let compressedBody;
         let compressPromise;
@@ -95,6 +135,10 @@ class Compressor {
               if (err) {
                 reject(err);
               } else {
+                // Permitir a los hooks modificar el buffer comprimido
+                if (this.hooks && this.hooks.applyFilters) {
+                  buffer = this.hooks.applyFilters('compressor_after_gzip', buffer, req, res, responseBody);
+                }
                 resolve(buffer);
               }
             });
@@ -105,6 +149,10 @@ class Compressor {
               if (err) {
                 reject(err);
               } else {
+                // Permitir a los hooks modificar el buffer comprimido
+                if (this.hooks && this.hooks.applyFilters) {
+                  buffer = this.hooks.applyFilters('compressor_after_deflate', buffer, req, res, responseBody);
+                }
                 resolve(buffer);
               }
             });
@@ -114,21 +162,46 @@ class Compressor {
         // Esperar a que se complete la compresión y enviar la respuesta
         compressPromise
           .then(compressed => {
+            // Permitir a los hooks modificar el cuerpo comprimido antes de enviar
+            if (this.hooks && this.hooks.applyFilters) {
+              compressed = this.hooks.applyFilters('compressor_before_send', compressed, req, res, compressionMethod);
+            }
+
             // Solo establecer encabezados si no se han enviado aún
             if (!res.headersSent) {
               // Establecer encabezados apropiados
               res.setHeader('Content-Encoding', compressionMethod);
               res.removeHeader('Content-Length'); // Eliminar Content-Length original
 
+              // Permitir a los hooks modificar los encabezados
+              if (this.hooks && this.hooks.doAction) {
+                this.hooks.doAction('compressor_before_headers_sent', req, res, compressionMethod);
+              }
+
               // Llamar al writeHead original
               originalWriteHead.call(res);
             }
 
+            // Permitir a los hooks modificar el comportamiento antes de enviar la respuesta
+            if (this.hooks && this.hooks.doAction) {
+              this.hooks.doAction('compressor_before_response_sent', req, res, compressed, compressionMethod);
+            }
+
             // Enviar el cuerpo comprimido
             originalEnd.call(res, compressed, encoding);
+
+            // Permitir a los hooks actuar después de enviar la respuesta
+            if (this.hooks && this.hooks.doAction) {
+              this.hooks.doAction('compressor_after_response_sent', req, res, compressed, compressionMethod);
+            }
           })
           .catch(err => {
             console.error('Error comprimiendo la respuesta:', err);
+            // Permitir a los hooks manejar el error de compresión
+            if (this.hooks && this.hooks.doAction) {
+              this.hooks.doAction('compressor_error_during_compression', err, req, res, responseBody, compressionMethod);
+            }
+
             // Si ocurre un error, enviar sin comprimir
             if (!res.headersSent) {
               res.removeHeader('Content-Encoding');
@@ -152,13 +225,18 @@ class Compressor {
   jsonOnly() {
     return (req, res, next) => {
       const originalSend = res.send; // Suponiendo que hay un método send
-      
+
       res.send = (data) => {
         // Verificar si el tipo de contenido es JSON
         const contentType = res.getHeader('Content-Type');
         if (contentType && contentType.includes('application/json')) {
           // Convertir a string si no lo es
-          const jsonString = typeof data === 'string' ? data : JSON.stringify(data);
+          let jsonString = typeof data === 'string' ? data : JSON.stringify(data);
+
+          // Permitir a los hooks modificar el JSON antes de la compresión
+          if (this.hooks && this.hooks.applyFilters) {
+            jsonString = this.hooks.applyFilters('compressor_json_before_compression', jsonString, req, res, data);
+          }
 
           // Continuar con la lógica de compresión
           // (similar a la implementación en middleware())
@@ -176,6 +254,11 @@ class Compressor {
             compressionMethod = 'deflate';
           }
 
+          // Permitir a los hooks modificar el método de compresión para JSON
+          if (this.hooks && this.hooks.applyFilters) {
+            compressionMethod = this.hooks.applyFilters('compressor_json_method', compressionMethod, req, res);
+          }
+
           if (!compressionMethod || !this.encodings.includes(compressionMethod)) {
             res.setHeader('Content-Type', 'application/json');
             originalSend.call(res, jsonString);
@@ -183,44 +266,112 @@ class Compressor {
           }
 
           if (Buffer.byteLength(jsonString) < this.threshold) {
-            res.setHeader('Content-Type', 'application/json');
-            res.removeHeader('Content-Encoding');
-            originalSend.call(res, jsonString);
-            return;
+            // Permitir a los hooks modificar el comportamiento cuando no se comprime JSON
+            if (this.hooks && this.hooks.applyFilters) {
+              const shouldCompressJSON = this.hooks.applyFilters('compressor_json_should_compress', false, jsonString, req, res, this.threshold);
+              if (!shouldCompressJSON) {
+                res.setHeader('Content-Type', 'application/json');
+                res.removeHeader('Content-Encoding');
+                originalSend.call(res, jsonString);
+                return;
+              }
+            } else {
+              res.setHeader('Content-Type', 'application/json');
+              res.removeHeader('Content-Encoding');
+              originalSend.call(res, jsonString);
+              return;
+            }
+          }
+
+          // Permitir a los hooks modificar el comportamiento antes de comprimir JSON
+          if (this.hooks && this.hooks.doAction) {
+            this.hooks.doAction('compressor_json_before_compression', req, res, jsonString, compressionMethod);
           }
 
           if (compressionMethod === 'gzip') {
             zlib.gzip(jsonString, this.gzipOptions, (err, compressed) => {
               if (err) {
                 console.error('Error comprimiendo JSON:', err);
+                // Permitir a los hooks manejar el error de compresión JSON
+                if (this.hooks && this.hooks.doAction) {
+                  this.hooks.doAction('compressor_json_error_during_compression', err, req, res, jsonString, compressionMethod);
+                }
+
                 if (!res.headersSent) {
                   res.setHeader('Content-Type', 'application/json');
                 }
                 originalSend.call(res, jsonString);
               } else {
+                // Permitir a los hooks modificar el JSON comprimido
+                if (this.hooks && this.hooks.applyFilters) {
+                  compressed = this.hooks.applyFilters('compressor_json_after_gzip', compressed, req, res, jsonString);
+                }
+
                 if (!res.headersSent) {
                   res.setHeader('Content-Encoding', compressionMethod);
                   res.removeHeader('Content-Length');
                   res.setHeader('Content-Type', 'application/json');
+
+                  // Permitir a los hooks modificar los encabezados antes de enviar JSON
+                  if (this.hooks && this.hooks.doAction) {
+                    this.hooks.doAction('compressor_json_before_headers_sent', req, res, compressionMethod);
+                  }
+                }
+
+                // Permitir a los hooks modificar el comportamiento antes de enviar JSON comprimido
+                if (this.hooks && this.hooks.doAction) {
+                  this.hooks.doAction('compressor_json_before_send', req, res, compressed, compressionMethod);
                 }
+
                 originalSend.call(res, compressed);
+
+                // Permitir a los hooks actuar después de enviar JSON comprimido
+                if (this.hooks && this.hooks.doAction) {
+                  this.hooks.doAction('compressor_json_after_send', req, res, compressed, compressionMethod);
+                }
               }
             });
           } else if (compressionMethod === 'deflate') {
             zlib.deflate(jsonString, this.deflateOptions, (err, compressed) => {
               if (err) {
                 console.error('Error comprimiendo JSON:', err);
+                // Permitir a los hooks manejar el error de compresión JSON
+                if (this.hooks && this.hooks.doAction) {
+                  this.hooks.doAction('compressor_json_error_during_compression', err, req, res, jsonString, compressionMethod);
+                }
+
                 if (!res.headersSent) {
                   res.setHeader('Content-Type', 'application/json');
                 }
                 originalSend.call(res, jsonString);
               } else {
+                // Permitir a los hooks modificar el JSON comprimido
+                if (this.hooks && this.hooks.applyFilters) {
+                  compressed = this.hooks.applyFilters('compressor_json_after_deflate', compressed, req, res, jsonString);
+                }
+
                 if (!res.headersSent) {
                   res.setHeader('Content-Encoding', compressionMethod);
                   res.removeHeader('Content-Length');
                   res.setHeader('Content-Type', 'application/json');
+
+                  // Permitir a los hooks modificar los encabezados antes de enviar JSON
+                  if (this.hooks && this.hooks.doAction) {
+                    this.hooks.doAction('compressor_json_before_headers_sent', req, res, compressionMethod);
+                  }
+                }
+
+                // Permitir a los hooks modificar el comportamiento antes de enviar JSON comprimido
+                if (this.hooks && this.hooks.doAction) {
+                  this.hooks.doAction('compressor_json_before_send', req, res, compressed, compressionMethod);
                 }
+
                 originalSend.call(res, compressed);
+
+                // Permitir a los hooks actuar después de enviar JSON comprimido
+                if (this.hooks && this.hooks.doAction) {
+                  this.hooks.doAction('compressor_json_after_send', req, res, compressed, compressionMethod);
+                }
               }
             });
           }
@@ -235,6 +386,103 @@ class Compressor {
       }
     };
   }
+  /**
+   * Método auxiliar para realizar la compresión
+   * @private
+   */
+  _performCompression(req, res, originalEnd, originalWriteHead, responseBody, compressionMethod) {
+    const zlib = require('zlib');
+
+    // Permitir a los hooks modificar el comportamiento cuando se va a comprimir
+    if (this.hooks && this.hooks.doAction) {
+      this.hooks.doAction('compressor_before_compression', req, res, responseBody, compressionMethod);
+    }
+
+    // Aplicar compresión según el método seleccionado
+    let compressedBody;
+    let compressPromise;
+
+    if (compressionMethod === 'gzip') {
+      compressPromise = new Promise((resolve, reject) => {
+        zlib.gzip(responseBody, this.gzipOptions, (err, buffer) => {
+          if (err) {
+            reject(err);
+          } else {
+            // Permitir a los hooks modificar el buffer comprimido
+            if (this.hooks && this.hooks.applyFilters) {
+              buffer = this.hooks.applyFilters('compressor_after_gzip', buffer, req, res, responseBody);
+            }
+            resolve(buffer);
+          }
+        });
+      });
+    } else if (compressionMethod === 'deflate') {
+      compressPromise = new Promise((resolve, reject) => {
+        zlib.deflate(responseBody, this.deflateOptions, (err, buffer) => {
+          if (err) {
+            reject(err);
+          } else {
+            // Permitir a los hooks modificar el buffer comprimido
+            if (this.hooks && this.hooks.applyFilters) {
+              buffer = this.hooks.applyFilters('compressor_after_deflate', buffer, req, res, responseBody);
+            }
+            resolve(buffer);
+          }
+        });
+      });
+    }
+
+    // Esperar a que se complete la compresión y enviar la respuesta
+    compressPromise
+      .then(compressed => {
+        // Permitir a los hooks modificar el cuerpo comprimido antes de enviar
+        if (this.hooks && this.hooks.applyFilters) {
+          compressed = this.hooks.applyFilters('compressor_before_send', compressed, req, res, compressionMethod);
+        }
+
+        // Solo establecer encabezados si no se han enviado aún
+        if (!res.headersSent) {
+          // Establecer encabezados apropiados
+          res.setHeader('Content-Encoding', compressionMethod);
+          res.removeHeader('Content-Length'); // Eliminar Content-Length original
+
+          // Permitir a los hooks modificar los encabezados
+          if (this.hooks && this.hooks.doAction) {
+            this.hooks.doAction('compressor_before_headers_sent', req, res, compressionMethod);
+          }
+
+          // Llamar al writeHead original
+          originalWriteHead.call(res);
+        }
+
+        // Permitir a los hooks modificar el comportamiento antes de enviar la respuesta
+        if (this.hooks && this.hooks.doAction) {
+          this.hooks.doAction('compressor_before_response_sent', req, res, compressed, compressionMethod);
+        }
+
+        // Enviar el cuerpo comprimido
+        originalEnd.call(res, compressed);
+
+        // Permitir a los hooks actuar después de enviar la respuesta
+        if (this.hooks && this.hooks.doAction) {
+          this.hooks.doAction('compressor_after_response_sent', req, res, compressed, compressionMethod);
+        }
+      })
+      .catch(err => {
+        console.error('Error comprimiendo la respuesta:', err);
+        // Permitir a los hooks manejar el error de compresión
+        if (this.hooks && this.hooks.doAction) {
+          this.hooks.doAction('compressor_error_during_compression', err, req, res, responseBody, compressionMethod);
+        }
+
+        // Si ocurre un error, enviar sin comprimir
+        if (!res.headersSent) {
+          res.removeHeader('Content-Encoding');
+          originalWriteHead.call(res);
+        }
+        originalEnd.call(res, responseBody);
+      });
+  }
 }
 
 module.exports = Compressor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jerkjs",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "JERK Framework v2.1 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, and template engine with performance optimizations",
   "main": "index.js",
   "scripts": {

package/standard/CompressionTestController.js

@@ -33,6 +33,24 @@ class CompressionTestController {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(largeData));
   }
+
+  // Nuevo endpoint para probar hooks de compresión
+  testCompressionHooks(req, res) {
+    // Datos para probar los hooks
+    const testData = {
+      message: 'Prueba de hooks de compresión',
+      hooksTest: true,
+      timestamp: new Date().toISOString(),
+      data: Array.from({ length: 500 }, (_, i) => ({
+        id: i,
+        testValue: `Valor de prueba ${i}`,
+        description: `Este es un elemento de prueba para verificar que los hooks de compresión funcionan correctamente`
+      }))
+    };
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(testData));
+  }
 }
 
 module.exports = new CompressionTestController();

package/standard/routes.json

@@ -54,5 +54,12 @@
     "controller": "CompressionTestController",
     "handler": "getLargeData",
     "contentType": "application/json"
+  },
+  {
+    "path": "/test-compression-hooks",
+    "method": "GET",
+    "controller": "CompressionTestController",
+    "handler": "testCompressionHooks",
+    "contentType": "application/json"
   }
 ]

package/standard/server.js

@@ -44,7 +44,7 @@ class StandardServer {
     this.authenticator = new Authenticator({ logger: this.logger });
     this.cors = new Cors();
     this.rateLimiter = new RateLimiter();
-    this.compressor = new Compressor();
+    this.compressor = new Compressor({ hooks: hooks });
     this.firewall = new Firewall({ logger: this.logger });
     this.sessionManager = new SessionManager();