jerkjs 2.5.6 → 2.6.1

package/lib/router/RouteMatcher.js

@@ -1,31 +1,79 @@
 /**
- * Componente especializado para la lógica de enrutado
+ * Componente especializado para la lógica de enrutado optimizado
  * Implementación del componente router/RouteMatcher.js
- * JERK Framework v2.1 - Separación de responsabilidades para enrutamiento
+ * JERK Framework v2.5.7 - Optimización de rendimiento con índices y pre-filtrado
  */
 
 class RouteMatcher {
   /**
-   * Constructor del matcher de rutas
+   * Constructor del matcher de rutas optimizado
    */
   constructor() {
     // Cache de expresiones regulares para rutas parametrizadas
     this.routeRegexCache = new Map();
+
+    // Índices para optimización
+    this.exactRoutes = new Map(); // Rutas exactas indexadas por método y path
+    this.routeBuckets = {}; // Rutas organizadas por método, número de segmentos y primer segmento
+    this.indexesValid = false;
+    
+    // Referencia al sistema de hooks (se establecerá externamente)
+    this.hooks = null;
+  }
+
+  /**
+   * Actualiza los índices basados en el conjunto actual de rutas
+   * @param {Array} routes - Array de rutas registradas
+   */
+  updateIndexes(routes) {
+    // Limpiar índices existentes
+    this.exactRoutes.clear();
+    this.routeBuckets = {};
+
+    // Reconstruir índices
+    for (const route of routes) {
+      // Indexar rutas exactas
+      const methodPathKey = `${route.method}:${route.path}`;
+      this.exactRoutes.set(methodPathKey, route);
+
+      // Organizar rutas en buckets por método, número de segmentos y primer segmento
+      const segments = route.path.split('/').filter(s => s !== '');
+      const segmentCount = segments.length;
+      const firstSegment = segments.length > 0 ? segments[0] : '';
+
+      // Inicializar estructura de buckets si no existe
+      if (!this.routeBuckets[route.method]) {
+        this.routeBuckets[route.method] = {};
+      }
+      if (!this.routeBuckets[route.method][segmentCount]) {
+        this.routeBuckets[route.method][segmentCount] = {};
+      }
+      if (!this.routeBuckets[route.method][segmentCount][firstSegment]) {
+        this.routeBuckets[route.method][segmentCount][firstSegment] = [];
+      }
+
+      // Agregar ruta al bucket correspondiente
+      this.routeBuckets[route.method][segmentCount][firstSegment].push(route);
+    }
+
+    this.indexesValid = true;
   }
 
   /**
-   * Método para encontrar una ruta coincidente
+   * Método para encontrar una ruta coincidente con optimizaciones
    * @param {Array} routes - Array de rutas registradas
    * @param {string} method - Método HTTP
    * @param {string} pathname - Ruta a buscar
    * @returns {Object|null} - Objeto de ruta encontrado o null
    */
   findRoute(routes, method, pathname) {
-    // Buscar ruta exacta primero
-    const exactMatch = routes.find(route =>
-      route.method === method && route.path === pathname
-    );
+    // Actualizar índices si es necesario
+    if (!this.indexesValid || routes.length !== this.getStoredRoutesCount()) {
+      this.updateIndexes(routes);
+    }
 
+    // Búsqueda por ruta exacta (más rápida)
+    const exactMatch = this.findExactMatch(method, pathname);
     if (exactMatch) {
       return {
         route: exactMatch,
@@ -33,45 +81,143 @@ class RouteMatcher {
       };
     }
 
-    // Buscar rutas estáticas que coincidan exactamente antes que rutas parametrizadas
-    // Esto permite que rutas estáticas como /css/style.css tengan prioridad sobre rutas parametrizadas
-    for (const route of routes) {
-      if (route.method !== method) continue;
-      
-      // Verificar si es una ruta estática que coincide exactamente
+    // Pre-filtrar rutas candidatas usando índices
+    const pathnameSegments = pathname.split('/').filter(s => s !== '');
+    const segmentCount = pathnameSegments.length;
+    const firstSegment = pathnameSegments.length > 0 ? pathnameSegments[0] : '';
+
+    // Obtener rutas candidatas basadas en número de segmentos y primer segmento
+    const candidateRoutes = this.getCandidateRoutes(method, segmentCount, firstSegment, pathname);
+
+    // Buscar rutas estáticas que coincidan exactamente
+    const staticExactMatch = this.findStaticExactMatch(candidateRoutes, pathname);
+    if (staticExactMatch) {
+      return {
+        route: staticExactMatch,
+        params: {}
+      };
+    }
+
+    // Buscar rutas parametrizadas entre los candidatos
+    const parametrizedMatch = this.findParametrizedMatch(candidateRoutes, pathname);
+    if (parametrizedMatch) {
+      return parametrizedMatch;
+    }
+
+    // Buscar rutas estáticas (prefijos) entre los candidatos
+    const staticPrefixMatch = this.findStaticPrefixMatch(candidateRoutes, pathname);
+    if (staticPrefixMatch) {
+      return staticPrefixMatch;
+    }
+
+    return null;
+  }
+
+  /**
+   * Busca rutas exactas usando el índice
+   * @param {string} method - Método HTTP
+   * @param {string} pathname - Ruta a buscar
+   * @returns {Object|null} - Ruta exacta encontrada o null
+   */
+  findExactMatch(method, pathname) {
+    const methodPathKey = `${method}:${pathname}`;
+    return this.exactRoutes.get(methodPathKey) || null;
+  }
+
+  /**
+   * Obtiene rutas candidatas basadas en número de segmentos y primer segmento
+   * @param {string} method - Método HTTP
+   * @param {number} segmentCount - Número de segmentos de la ruta buscada
+   * @param {string} firstSegment - Primer segmento de la ruta buscada
+   * @param {string} pathname - Ruta completa buscada
+   * @returns {Array} - Array de rutas candidatas
+   */
+  getCandidateRoutes(method, segmentCount, firstSegment, pathname) {
+    const candidates = [];
+
+    // Si existe un bucket para este método, número de segmentos y primer segmento
+    if (this.routeBuckets[method] && 
+        this.routeBuckets[method][segmentCount] && 
+        this.routeBuckets[method][segmentCount][firstSegment]) {
+      candidates.push(...this.routeBuckets[method][segmentCount][firstSegment]);
+    }
+
+    // También agregar rutas de otros primeros segmentos para este método y número de segmentos
+    // (por si hay rutas parametrizadas que también podrían coincidir)
+    if (this.routeBuckets[method] && this.routeBuckets[method][segmentCount]) {
+      for (const segment in this.routeBuckets[method][segmentCount]) {
+        if (segment !== firstSegment) {
+          candidates.push(...this.routeBuckets[method][segmentCount][segment]);
+        }
+      }
+    }
+
+    // Agregar rutas estáticas que podrían coincidir por prefijo
+    if (this.routeBuckets[method]) {
+      for (const count in this.routeBuckets[method]) {
+        for (const segment in this.routeBuckets[method][count]) {
+          const routes = this.routeBuckets[method][count][segment];
+          for (const route of routes) {
+            if (route.isStatic && pathname.startsWith(route.path)) {
+              candidates.push(route);
+            }
+          }
+        }
+      }
+    }
+
+    return candidates;
+  }
+
+  /**
+   * Busca rutas estáticas con coincidencia exacta entre candidatos
+   * @param {Array} candidateRoutes - Rutas candidatas
+   * @param {string} pathname - Ruta a buscar
+   * @returns {Object|null} - Ruta estática exacta encontrada o null
+   */
+  findStaticExactMatch(candidateRoutes, pathname) {
+    for (const route of candidateRoutes) {
       if (route.isStatic && route.path === pathname) {
-        return {
-          route: route,
-          params: {}
-        };
+        return route;
       }
     }
+    return null;
+  }
 
-    // Buscar rutas parametrizadas
-    // Pero antes de devolver una ruta parametrizada, verificar si hay una ruta estática más específica
-    const parametrizedMatches = [];
-    for (const route of routes) {
-      if (route.method !== method) continue;
-
-      // Convertir ruta parametrizada a expresión regular
-      const routeRegex = this.pathToRegex(route.path);
-      const match = pathname.match(routeRegex);
-
-      if (match) {
-        const params = this.extractParams(route.path, pathname);
-        parametrizedMatches.push({
-          route: route,
-          params: params
-        });
+  /**
+   * Busca rutas parametrizadas entre candidatos
+   * @param {Array} candidateRoutes - Rutas candidatas
+   * @param {string} pathname - Ruta a buscar
+   * @returns {Object|null} - Ruta parametrizada encontrada o null
+   */
+  findParametrizedMatch(candidateRoutes, pathname) {
+    for (const route of candidateRoutes) {
+      if (this.isParametrizedRoute(route.path)) {
+        // Convertir ruta parametrizada a expresión regular
+        const routeRegex = this.pathToRegex(route.path);
+        const match = pathname.match(routeRegex);
+
+        if (match) {
+          const params = this.extractParams(route.path, pathname);
+          return {
+            route: route,
+            params: params
+          };
+        }
       }
     }
+    return null;
+  }
 
-    // Buscar rutas estáticas (prefijos)
+  /**
+   * Busca rutas estáticas por prefijo entre candidatos
+   * @param {Array} candidateRoutes - Rutas candidatas
+   * @param {string} pathname - Ruta a buscar
+   * @returns {Object|null} - Ruta estática por prefijo encontrada o null
+   */
+  findStaticPrefixMatch(candidateRoutes, pathname) {
     const staticMatches = [];
-    for (const route of routes) {
-      if (route.method !== method) continue;
-
-      // Para rutas estáticas, verificar si la ruta solicitada comienza con el prefijo de la ruta estática
+    for (const route of candidateRoutes) {
       if (route.isStatic && pathname.startsWith(route.path)) {
         // Verificar que sea exactamente el prefijo o que haya una barra después del prefijo
         const remainingPath = pathname.substring(route.path.length);
@@ -85,27 +231,40 @@ class RouteMatcher {
       }
     }
 
-    // Prioridad: si hay rutas estáticas que coinciden, y la solicitud parece ser para un archivo
-    // (tiene extensión), dar prioridad a la ruta estática más específica
-    const hasFileExtension = /\.[^.]+$/.test(pathname);
-
-    if (hasFileExtension && staticMatches.length > 0) {
+    if (staticMatches.length > 0) {
       // Ordenar por especificidad (longitud del prefijo, descendente) y tomar la más específica
       staticMatches.sort((a, b) => b.specificity - a.specificity);
-      // Para solicitudes de archivos, dar prioridad a rutas estáticas más específicas
-      return staticMatches[0]; // Devolver la coincidencia estática más específica
-    } else if (parametrizedMatches.length > 0) {
-      // Para solicitudes sin extensión o rutas API, dar prioridad a rutas parametrizadas
-      return parametrizedMatches[0]; // Devolver la primera coincidencia parametrizada
-    } else if (staticMatches.length > 0) {
-      // Si no hay coincidencias parametrizadas, usar la estática más específica
-      staticMatches.sort((a, b) => b.specificity - a.specificity);
       return staticMatches[0];
     }
 
     return null;
   }
 
+  /**
+   * Determina si una ruta es parametrizada
+   * @param {string} path - Ruta a verificar
+   * @returns {boolean} - True si la ruta contiene parámetros
+   */
+  isParametrizedRoute(path) {
+    return path.includes(':');
+  }
+
+  /**
+   * Obtiene el conteo total de rutas almacenadas en índices
+   * @returns {number} - Número total de rutas indexadas
+   */
+  getStoredRoutesCount() {
+    let count = 0;
+    for (const method in this.routeBuckets) {
+      for (const segmentCount in this.routeBuckets[method]) {
+        for (const firstSegment in this.routeBuckets[method][segmentCount]) {
+          count += this.routeBuckets[method][segmentCount][firstSegment].length;
+        }
+      }
+    }
+    return count;
+  }
+
   /**
    * Convierte una ruta con parámetros a expresión regular
    * @param {string} path - Ruta con posibles parámetros
@@ -131,8 +290,20 @@ class RouteMatcher {
     const regexPath = escapedPath.replace(/:([a-zA-Z0-9_]+)/g, '([^/]+?)');
     const regex = new RegExp(`^${regexPath}$`);
 
-    // Almacenar en caché
-    this.routeRegexCache.set(path, regex);
+    // Verificar con hook si se debe cachear esta expresión regular
+    const shouldCache = this.hooks ? 
+      this.hooks.applyFilters('should_cache_route_regex', true, path, regex) : true;
+    
+    if (shouldCache) {
+      // Almacenar en caché
+      this.routeRegexCache.set(path, regex);
+      
+      // Disparar hook después de cachear
+      if (this.hooks) {
+        this.hooks.doAction('route_regex_cached', path, regex);
+      }
+    }
+    
     return regex;
   }
 
@@ -169,6 +340,23 @@ class RouteMatcher {
 
     return params;
   }
+
+  /**
+   * Limpia el caché de expresiones regulares
+   */
+  clearCache() {
+    // Disparar hook antes de limpiar el caché
+    if (this.hooks) {
+      this.hooks.doAction('before_route_regex_cache_clear', this);
+    }
+    
+    this.routeRegexCache.clear();
+    
+    // Disparar hook después de limpiar el caché
+    if (this.hooks) {
+      this.hooks.doAction('route_regex_cache_cleared');
+    }
+  }
 }
 
 module.exports = RouteMatcher;

package/lib/utils/globalStats.js

@@ -0,0 +1,16 @@
+/**
+ * Almacenamiento global de estadísticas para el framework JERK
+ */
+
+// Crear un objeto global para almacenar estadísticas
+const globalStats = {
+  requestsProcessed: 0,
+  responsesSent: 0,
+  requestBytes: 0,
+  responseBytes: 0,
+  routeAccesses: new Map(), // Contador de accesos por ruta
+  endpointHits: new Map(), // Contador de hits por endpoint
+  lastRequests: [] // Últimas solicitudes para análisis
+};
+
+module.exports = { globalStats };

package/lib/utils/globalViewCacheInfo.js

@@ -0,0 +1,16 @@
+/**
+ * Almacenamiento global de información del caché de vistas para el framework JERK
+ */
+
+// Crear un objeto global para almacenar información del caché de vistas
+const globalViewCacheInfo = {
+  viewCache: new Map(), // Cache de vistas compiladas
+  cacheStats: {
+    hits: 0,
+    misses: 0,
+    totalViews: 0
+  },
+  viewDependencies: new Map() // Registro de dependencias entre vistas (inclusiones)
+};
+
+module.exports = { globalViewCacheInfo };

package/lib/utils/globalWAFStats.js

@@ -0,0 +1,54 @@
+/**
+ * Sistema de Almacenamiento Global de Estadísticas del WAF (Web Application Firewall)
+ * Almacenamiento centralizado de datos del firewall para acceso eficiente
+ */
+
+// Objeto global para almacenar estadísticas del WAF
+const globalWAFStats = {
+  // Contadores de solicitudes
+  requestsProcessed: 0,
+  responsesSent: 0,
+  
+  // Contadores de bytes
+  requestBytes: 0,
+  responseBytes: 0,
+  
+  // Registro de accesos a rutas
+  routeAccesses: new Map(), // Mapa de rutas y número de accesos
+  
+  // Registro de hits a endpoints
+  endpointHits: new Map(), // Mapa de endpoints y número de hits
+  
+  // IPs bloqueadas temporalmente
+  blockedIPs: new Map(), // Mapa de IPs bloqueadas con información de bloqueo
+  
+  // IPs en lista blanca (nunca bloqueadas)
+  whitelist: new Set(),
+  
+  // IPs en lista negra (siempre bloqueadas)
+  blacklist: new Set(),
+  
+  // Reglas de seguridad activas
+  securityRules: new Map(), // Mapa de reglas de seguridad
+
+  // Reglas de headers X-
+  xHeaderRules: new Map(), // Mapa de reglas de headers X-
+
+  // Tipos de ataques detectados
+  attackTypes: new Set(), // Conjunto de tipos de ataques detectados
+
+  // Contador de intentos de ataque
+  attackAttempts: 0,
+
+  // Registros de seguridad
+  securityLogs: [],
+
+  // Estadísticas de rendimiento
+  performanceStats: {
+    startTime: new Date().toISOString(),
+    requestProcessingTime: 0,
+    averageResponseTime: 0
+  }
+};
+
+module.exports = { globalWAFStats };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jerkjs",
-  "version": "2.5.6",
-  "description": "JERK Framework v2.5.6 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, template engine, integration with qbuilderjs, complete MVC architecture with models, enhanced route loading from directory, improved model loading system, and fixed routing issues with static and parametrized routes",
+  "version": "2.6.1",
+  "description": "JERK Framework v2.6.1 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, template engine, integration with qbuilderjs, complete MVC architecture with models, enhanced route loading from directory, improved model loading system, administration extension, queue management system, route cache management module, and fixed routing issues with static and parametrized routes",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/test-colors.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+/**
+ * Script de prueba para verificar que los colores funcionan en el módulo de cache de rutas
+ * Este script simula la interacción con el módulo para verificar la visualización de comandos en color
+ */
+
+// Simulación de socket para probar la funcionalidad de color
+const mockSocket = {
+  data: '',
+  write: function(text) {
+    this.data += text;
+    // En un entorno real, esto escribiría en el socket
+    process.stdout.write(text);
+  }
+};
+
+// Importar el módulo
+const RouteCacheModule = require('./lib/admin/modules/RouteCacheModule');
+
+// Crear una instancia simulada de adminExtension
+const mockAdminExtension = {
+  frameworkInstance: {
+    routeMatcher: {
+      routeRegexCache: new Map([
+        ['/users/:id', /^\/users\/([^\/]+?)$/],
+        ['/posts/:slug', /^\/posts\/([^\/]+?)$/]
+      ]),
+      exactRoutes: new Map([
+        ['GET:/api/users', { handler: { name: 'getUserHandler' }, isStatic: false }],
+        ['POST:/api/users', { handler: { name: 'createUserHandler' }, isStatic: false }]
+      ]),
+      indexesValid: true
+    }
+  }
+};
+
+// Crear instancia del módulo
+const routeCacheModule = new RouteCacheModule(mockAdminExtension);
+
+console.log('Probando el módulo de cache de rutas con colores...\n');
+
+// Probar el manejo de un comando desconocido para ver el mensaje con comandos en verde
+routeCacheModule.handleCommand('comando-invalido', mockSocket);
+
+console.log('\nFin de la prueba.');

package/test-help-alias.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+/**
+ * Script de prueba para verificar que el alias '?' funciona en el sistema de administración
+ */
+
+const { APIServer } = require('./index.js');
+
+// Crear instancia del servidor
+const server = new APIServer({ port: 3001 }); // Usar un puerto diferente para evitar conflictos
+
+// Agregar una ruta de ejemplo
+server.addRoute('GET', '/', (req, res) => {
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.end('Hola Mundo!');
+});
+
+// Inicializar la extensión de administración
+server.initializeAdminExtension({
+  port: 9998, // Usar un puerto diferente para evitar conflictos
+  host: '127.0.0.1'
+});
+
+console.log('Servidor de prueba iniciado en http://localhost:3001');
+console.log('Servidor de administración en tcp://localhost:9998');
+console.log('\nPara probar el alias "?":');
+console.log('- Conéctate al servidor de administración con: telnet localhost 9998 o nc localhost 9998');
+console.log('- Escribe "?" y presiona Enter para ver la ayuda');
+
+// Iniciar el servidor
+server.start();