jerkjs 2.5.6 → 2.6.1

package/lib/middleware/firewall.js

@@ -170,26 +170,31 @@ class Firewall {
     // Path traversal
     const pathTraversal = /\.\.\//g;
 
-    // Verificar patrones en URL
-    for (const pattern of sqlPatterns) {
-      if (pattern.test(path)) {
-        return {
-          matched: true,
-          rule: 'sql_injection',
-          action: 'block',
-          reason: 'Patrón de SQL Injection detectado'
-        };
+    // Verificar patrones en URL solo si hay parámetros (evitar falsos positivos)
+    if (path.includes('?')) {
+      for (const pattern of sqlPatterns) {
+        if (pattern.test(path)) {
+          return {
+            matched: true,
+            rule: 'sql_injection',
+            action: 'block',
+            reason: 'Patrón de SQL Injection detectado'
+          };
+        }
       }
     }
 
-    for (const pattern of xssPatterns) {
-      if (pattern.test(path)) {
-        return {
-          matched: true,
-          rule: 'xss_attack',
-          action: 'block',
-          reason: 'Patrón de XSS detectado'
-        };
+    // Verificar patrones XSS solo si hay parámetros (evitar falsos positivos)
+    if (path.includes('?')) {
+      for (const pattern of xssPatterns) {
+        if (pattern.test(path)) {
+          return {
+            matched: true,
+            rule: 'xss_attack',
+            action: 'block',
+            reason: 'Patrón de XSS detectado'
+          };
+        }
       }
     }
 
@@ -202,6 +207,34 @@ class Firewall {
       };
     }
 
+    // Verificar reglas personalizadas de headers X-
+    const { globalWAFStats } = require('../utils/globalWAFStats');
+    for (const [ruleId, rule] of globalWAFStats.xHeaderRules) {
+      const headerValue = headers[rule.headerName];
+      if (headerValue) {
+        // Verificar si coincide con el patrón de la regla
+        if (typeof rule.pattern === 'string') {
+          if (headerValue.includes(rule.pattern)) {
+            return {
+              matched: true,
+              rule: ruleId,
+              action: rule.action,
+              reason: rule.reason
+            };
+          }
+        } else if (rule.pattern instanceof RegExp) {
+          if (rule.pattern.test(headerValue)) {
+            return {
+              matched: true,
+              rule: ruleId,
+              action: rule.action,
+              reason: rule.reason
+            };
+          }
+        }
+      }
+    }
+
     // Verificar patrones en body si es string
     if (typeof body === 'string') {
       for (const pattern of sqlPatterns) {
@@ -374,16 +407,35 @@ class Firewall {
 
       const clientIP = this.getClientIP(req);
 
+      // Actualizar estadísticas globales de solicitudes procesadas
+      const { globalWAFStats } = require('../utils/globalWAFStats');
+      globalWAFStats.requestsProcessed++;
+
+      // Capturar el tamaño del cuerpo de la solicitud si existe
+      if (req.body) {
+        const bodySize = typeof req.body === 'string' ? Buffer.byteLength(req.body, 'utf8') :
+                         typeof req.body === 'object' ? Buffer.byteLength(JSON.stringify(req.body), 'utf8') : 0;
+        globalWAFStats.requestBytes += bodySize;
+        console.log(`[FIREWALL DEBUG] Bytes de solicitud actualizados: ${globalWAFStats.requestBytes}`);
+      } else {
+        console.log('[FIREWALL DEBUG] No hay cuerpo en la solicitud');
+      }
+
       // Verificar si la IP está bloqueada
       const blockInfo = this.isBlocked(clientIP);
       if (blockInfo.blocked) {
         this.logger.warn(`Solicitud bloqueada desde IP: ${clientIP}, razón: ${blockInfo.reason}`);
+        console.log(`[FIREWALL DEBUG] Solicitud bloqueada desde IP: ${clientIP}, razón: ${blockInfo.reason}`);
 
         // Disparar hook de evento de seguridad
         if (hooks) {
           hooks.doAction('firewall_ip_blocked', clientIP, blockInfo.reason, req, res);
         }
 
+        // Actualizar estadísticas de intentos de ataque
+        globalWAFStats.attackAttempts++;
+        console.log(`[FIREWALL DEBUG] Ataque detectado, attackAttempts ahora: ${globalWAFStats.attackAttempts}`);
+
         res.writeHead(403, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({
           error: 'Acceso denegado por firewall',
@@ -412,6 +464,14 @@ class Firewall {
             hooks.doAction('firewall_request_blocked', ruleMatch, clientIP, req, res);
           }
 
+          // Actualizar estadísticas de intentos de ataque
+          globalWAFStats.attackAttempts++;
+          console.log(`[FIREWALL DEBUG] Ataque bloqueado, attackAttempts ahora: ${globalWAFStats.attackAttempts}`);
+          
+          // Registrar el tipo de ataque
+          globalWAFStats.attackTypes.add(ruleMatch.rule);
+          console.log(`[FIREWALL DEBUG] Tipo de ataque registrado: ${ruleMatch.rule}`);
+
           res.writeHead(403, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({
             error: 'Solicitud bloqueada por firewall',
@@ -429,11 +489,46 @@ class Firewall {
         }
       }
 
+      // Registrar acceso a ruta en las estadísticas globales
+      const routeKey = `${req.method} ${req.url}`;
+      if (!globalWAFStats.routeAccesses.has(routeKey)) {
+        globalWAFStats.routeAccesses.set(routeKey, 0);
+      }
+      globalWAFStats.routeAccesses.set(routeKey, globalWAFStats.routeAccesses.get(routeKey) + 1);
+      console.log(`[FIREWALL DEBUG] Acceso a ruta registrado: ${routeKey}, total accesos: ${globalWAFStats.routeAccesses.get(routeKey)}`);
+
+      // Registrar hit al endpoint en las estadísticas globales
+      const endpointKey = `${req.method} ${req.url}`;
+      if (!globalWAFStats.endpointHits.has(endpointKey)) {
+        globalWAFStats.endpointHits.set(endpointKey, 0);
+      }
+      globalWAFStats.endpointHits.set(endpointKey, globalWAFStats.endpointHits.get(endpointKey) + 1);
+      console.log(`[FIREWALL DEBUG] Hit al endpoint registrado: ${endpointKey}, total hits: ${globalWAFStats.endpointHits.get(endpointKey)}`);
+
       // Disparar hook antes de continuar con el siguiente middleware
       if (hooks) {
         hooks.doAction('firewall_request_allowed', req, res);
       }
 
+      // Capturar el tamaño de la respuesta antes de enviarla
+      const originalEnd = res.end;
+      res.end = (chunk, encoding, callback) => {
+        console.log(`[FIREWALL DEBUG] Enviando respuesta, tamaño del chunk: ${chunk ? Buffer.byteLength(chunk, typeof encoding === 'string' ? encoding : 'utf8') : 0} bytes`);
+        
+        // Actualizar estadísticas globales de respuestas enviadas
+        globalWAFStats.responsesSent++;
+        console.log(`[FIREWALL DEBUG] responsesSent ahora: ${globalWAFStats.responsesSent}`);
+        
+        // Capturar el tamaño del cuerpo de la respuesta si existe
+        if (chunk) {
+          const responseSize = Buffer.byteLength(chunk, typeof encoding === 'string' ? encoding : 'utf8');
+          globalWAFStats.responseBytes += responseSize;
+          console.log(`[FIREWALL DEBUG] responseBytes ahora: ${globalWAFStats.responseBytes}`);
+        }
+
+        return originalEnd.call(res, chunk, encoding, callback);
+      };
+
       // Continuar con el siguiente middleware
       next();
     };

package/lib/mvc/viewEngine.js

@@ -7,24 +7,29 @@
 
 const fs = require('fs');
 const path = require('path');
+const { globalViewCacheInfo } = require('../utils/globalViewCacheInfo');
 
 class ViewEngine {
   constructor(options = {}) {
     this.viewsPath = options.viewsPath || './views';
     this.defaultExtension = options.defaultExtension || '.html';
     this.cacheEnabled = options.cacheEnabled !== false; // Por defecto habilitado
-    this.viewCache = new Map(); // Cache de vistas compiladas
     this.logger = options.logger || console;
-    
+
+    // Usar el mapa global para el caché de vistas
+    this.viewCache = globalViewCacheInfo.viewCache;
+    this.cacheStats = globalViewCacheInfo.cacheStats;
+    this.viewDependencies = globalViewCacheInfo.viewDependencies;
+
     // Sistema de hooks para extensibilidad
     this.hooks = options.hooks || null;
-    
+
     // Sistema de filtros
     this.filters = new Map();
     this.helpers = new Map(); // Sistema de helpers personalizados
     this.registerDefaultFilters();
     this.registerDefaultHelpers();
-    
+
     // Asegurar que el directorio de vistas existe
     if (!fs.existsSync(this.viewsPath)) {
       fs.mkdirSync(this.viewsPath, { recursive: true });
@@ -224,6 +229,7 @@ class ViewEngine {
     // Intentar obtener del cache si está habilitado
     if (this.cacheEnabled && this.viewCache.has(viewPath)) {
       const cachedView = this.viewCache.get(viewPath);
+      this.cacheStats.hits++; // Incrementar contador de hits
       return this.processTemplate(cachedView, data, options);
     }
 
@@ -274,7 +280,31 @@ class ViewEngine {
 
     // Si el cache está habilitado, guardar la vista compilada (sin variables)
     if (this.cacheEnabled) {
-      this.viewCache.set(viewPath, viewContent);
+      // Aplicar filter antes de cachear la vista
+      const contentToCache = this.hooks ?
+        this.hooks.applyFilters('before_view_cache', viewContent, viewPath) : viewContent;
+
+      // Verificar con hook si se debe cachear esta vista
+      const shouldCache = this.hooks ?
+        this.hooks.applyFilters('should_cache_view', true, viewPath, contentToCache) : true;
+
+      if (shouldCache) {
+        this.viewCache.set(viewPath, contentToCache);
+        this.cacheStats.misses++; // Incrementar contador de misses (ya que se leyó del disco)
+        this.cacheStats.totalViews++; // Incrementar total de vistas únicas
+
+        // Registrar dependencias de inclusiones
+        this.trackViewDependencies(viewPath, contentToCache);
+
+        // Disparar hook después de cachear
+        if (this.hooks) {
+          this.hooks.doAction('view_cached', viewPath, contentToCache);
+        }
+      } else {
+        this.cacheStats.misses++; // Aún se leyó del disco aunque no se cacheó
+      }
+    } else {
+      this.cacheStats.misses++; // Se leyó del disco sin cache
     }
 
     // Procesar el template con las variables
@@ -760,6 +790,42 @@ class ViewEngine {
     return value;
   }
 
+  /**
+   * Registra las dependencias de inclusiones de una vista
+   * @param {string} viewPath - Ruta de la vista principal
+   * @param {string} content - Contenido de la vista
+   */
+  trackViewDependencies(viewPath, content) {
+    // Patrón para encontrar bloques de inclusión como {{include:nombre_vista}}
+    const includePattern = /\{\{include:(.*?)\}\}/g;
+    let match;
+    
+    while ((match = includePattern.exec(content)) !== null) {
+      const includePath = match[1].trim();
+      
+      // Obtener la ruta completa de la vista incluida
+      let includedViewPath;
+      if (includePath.startsWith('./') || includePath.startsWith('../')) {
+        includedViewPath = path.resolve(path.dirname(viewPath), includePath);
+        if (!path.extname(includedViewPath)) {
+          includedViewPath += this.defaultExtension;
+        }
+      } else {
+        // Usar la ruta de vistas por defecto
+        includedViewPath = path.join(this.viewsPath, includePath.replace(/\./g, '/'));
+        if (!path.extname(includedViewPath)) {
+          includedViewPath += this.defaultExtension;
+        }
+      }
+
+      // Registrar la dependencia
+      if (!this.viewDependencies.has(viewPath)) {
+        this.viewDependencies.set(viewPath, new Set());
+      }
+      this.viewDependencies.get(viewPath).add(includedViewPath);
+    }
+  }
+
   /**
    * Parsea argumentos de filtros o helpers, respetando cadenas entre comillas
    * @param {string} argsString - Cadena de argumentos
@@ -817,7 +883,25 @@ class ViewEngine {
    * Limpia el cache de vistas
    */
   clearCache() {
+    // Disparar hook antes de limpiar el caché
+    if (this.hooks) {
+      this.hooks.doAction('before_view_cache_clear', this);
+    }
+
+    // Limpiar solo las vistas asociadas a esta instancia (si se desea)
+    // Para el sistema global, limpiar completamente
     this.viewCache.clear();
+    this.viewDependencies.clear();
+    
+    // Reiniciar estadísticas
+    this.cacheStats.hits = 0;
+    this.cacheStats.misses = 0;
+    this.cacheStats.totalViews = 0;
+
+    // Disparar hook después de limpiar el caché
+    if (this.hooks) {
+      this.hooks.doAction('view_cache_cleared');
+    }
   }
 }
 

package/lib/queue/GlobalQueueStorage.js

@@ -0,0 +1,38 @@
+/**
+ * Almacenamiento Global de Colas para el Framework JERK
+ * Implementación del componente queue/GlobalQueueStorage.js
+ * Sistema de almacenamiento compartido globalmente para las colas
+ */
+
+// Crear espacio de almacenamiento global para las colas si no existe
+if (!global.jerkQueues) {
+  global.jerkQueues = new Map();
+}
+
+if (!global.jerkQueueSystems) {
+  global.jerkQueueSystems = new Map();
+}
+
+if (!global.jerkQueueSystem) {
+  // Importar dinámicamente para evitar dependencias circulares
+  const QueueSystem = require('./QueueSystem');
+  const HookSystem = require('../core/hooks');
+  
+  // Obtener hooks globales del framework si están disponibles
+  let globalHooks = null;
+  try {
+    const framework = require('../../index.js');
+    globalHooks = framework.hooks;
+  } catch (error) {
+    // Si no están disponibles, crear instancia local
+    globalHooks = new HookSystem();
+  }
+  
+  global.jerkQueueSystem = new QueueSystem({ hooks: globalHooks });
+}
+
+module.exports = {
+  queues: global.jerkQueues,
+  queueSystems: global.jerkQueueSystems,
+  queueSystem: global.jerkQueueSystem
+};