jerkjs 2.5.6 → 2.5.8

package/lib/core/server.js

@@ -13,6 +13,8 @@ const { Logger } = require('../utils/logger');
 const { ErrorHandler } = require('../utils/errorHandler');
 const { getMimeType } = require('../utils/mimeType');
 const RouteMatcher = require('../router/RouteMatcher');
+const AdminExtension = require('../admin/AdminExtension');
+const { globalStats } = require('../utils/globalStats');
 
 // Carga anticipada de módulos comunes para evitar cargas repetidas
 let hooksInstance = null;
@@ -59,6 +61,42 @@ class APIServer {
 
     // Inicializar el componente de enrutamiento
     this.routeMatcher = new RouteMatcher();
+    
+    // Inicializar la extensión de administración
+    this.adminExtension = null;
+    
+    // Inicializar el sistema de hooks si no existe
+    if (!options.hooks) {
+      const { hooks } = require('../../index.js');  // Ruta corregida
+      this.hooks = hooks;
+    } else {
+      this.hooks = options.hooks;
+    }
+    
+    // Conectar el sistema de hooks al routeMatcher
+    this.routeMatcher.hooks = this.hooks;
+    
+    // Propiedad para almacenar el viewEngine
+    this._viewEngine = null;
+  }
+
+  /**
+   * Setter para el viewEngine que también conecta los hooks
+   */
+  set viewEngine(engine) {
+    this._viewEngine = engine;
+    
+    // Conectar el sistema de hooks al viewEngine si está disponible
+    if (this._viewEngine && this.hooks) {
+      this._viewEngine.hooks = this.hooks;
+    }
+  }
+
+  /**
+   * Getter para el viewEngine
+   */
+  get viewEngine() {
+    return this._viewEngine;
   }
 
   /**
@@ -353,12 +391,18 @@ class APIServer {
       // Crear handler para archivos estáticos
       const staticHandler = this.createStaticFileHandler(routeConfig.static, routeConfig.path);
 
-      this.routes.push({
+      const route = {
         method: routeConfig.method.toUpperCase(),
         path: routeConfig.path,
         handler: staticHandler,
         isStatic: true // Marcar como ruta estática para posible procesamiento especial
-      });
+      };
+      this.routes.push(route);
+      
+      // Disparar hook cuando se registra una ruta
+      if (this.hooks) {
+        this.hooks.doAction('route_registered', route);
+      }
 
       return; // Salir después de procesar ruta estática
     }
@@ -437,11 +481,17 @@ class APIServer {
           };
 
           // Agregar la ruta con el handler autenticado
-          this.routes.push({
+          const route = {
             method: routeConfig.method.toUpperCase(),
             path: routeConfig.path,
             handler: authenticatedHandler
-          });
+          };
+          this.routes.push(route);
+          
+          // Disparar hook cuando se registra una ruta
+          if (this.hooks) {
+            this.hooks.doAction('route_registered', route);
+          }
         } else {
           // Si no hay sessionManager en el servidor, agregar la ruta normalmente
           this.routes.push({
@@ -488,27 +538,45 @@ class APIServer {
           };
 
           // Agregar la ruta con el handler autenticado
-          this.routes.push({
+          const route = {
             method: routeConfig.method.toUpperCase(),
             path: routeConfig.path,
             handler: authenticatedHandler
-          });
+          };
+          this.routes.push(route);
+          
+          // Disparar hook cuando se registra una ruta
+          if (this.hooks) {
+            this.hooks.doAction('route_registered', route);
+          }
         } else {
           // Si no hay authenticator en el servidor, agregar la ruta normalmente
-          this.routes.push({
+          const route = {
             method: routeConfig.method.toUpperCase(),
             path: routeConfig.path,
             handler: finalHandler
-          });
+          };
+          this.routes.push(route);
+          
+          // Disparar hook cuando se registra una ruta
+          if (this.hooks) {
+            this.hooks.doAction('route_registered', route);
+          }
         }
       }
     } else {
       // Si no hay autenticación requerida, agregar la ruta normalmente
-      this.routes.push({
+      const route = {
         method: routeConfig.method.toUpperCase(),
         path: routeConfig.path,
         handler: finalHandler
-      });
+      };
+      this.routes.push(route);
+      
+      // Disparar hook cuando se registra una ruta
+      if (this.hooks) {
+        this.hooks.doAction('route_registered', route);
+      }
     }
   }
 
@@ -579,12 +647,28 @@ class APIServer {
       // Disparar hook después de iniciar el servidor
       if (hooks) {
         hooks.doAction('post_server_start', this);
+        
+        // Disparar hook para inicializar extensiones después de que el servidor esté completamente iniciado
+        hooks.doAction('admin_extensions_initialize', this);
       }
     });
 
     return this.server;
   }
 
+  /**
+   * Inicializa la extensión de administración
+   * @param {Object} options - Opciones para la extensión de administración
+   */
+  initializeAdminExtension(options = {}) {
+    if (!this.adminExtension) {
+      this.adminExtension = new AdminExtension(options);
+      this.adminExtension.initialize(this);
+    }
+    
+    return this.adminExtension;
+  }
+
   /**
    * Detiene el servidor
    */
@@ -594,6 +678,11 @@ class APIServer {
         this.logger.info('Servidor detenido');
       });
     }
+    
+    // Cerrar la extensión de administración si está activa
+    if (this.adminExtension) {
+      this.adminExtension.close();
+    }
   }
 
   /**
@@ -643,6 +732,9 @@ class APIServer {
         // Concatenar todos los chunks una sola vez
         req.body = Buffer.concat(bodyChunks).toString();
 
+        // Actualizar estadísticas globales de bytes recibidos
+        globalStats.requestBytes += bodySize;
+
         // Parsear body si es JSON
         if (req.headers['content-type'] && req.headers['content-type'].includes('application/json')) {
           try {
@@ -802,9 +894,60 @@ class APIServer {
               }
             }
 
+            // Capturar el tamaño de la respuesta antes de enviarla
+            const originalWrite = res.write;
+            const originalEnd = res.end;
+            let responseData = [];
+
+            res.write = function(chunk) {
+              if (chunk) {
+                responseData.push(Buffer.from(chunk));
+              }
+              return originalWrite.apply(this, arguments);
+            };
+
+            res.end = function(chunk) {
+              if (chunk) {
+                responseData.push(Buffer.from(chunk));
+              }
+              
+              // Almacenar los datos de la respuesta para estadísticas
+              res._data = Buffer.concat(responseData);
+              
+              // Actualizar estadísticas globales de bytes enviados
+              if (res._data) {
+                const responseSize = Buffer.byteLength(res._data, 'utf8');
+                globalStats.responseBytes += responseSize;
+              }
+              
+              return originalEnd.apply(this, arguments);
+            };
+
+            // Actualizar estadísticas globales de solicitudes procesadas
+            globalStats.requestsProcessed++;
+
             // Ejecutar handler de la ruta
             await matchedRoute.route.handler(req, res);
 
+            // Actualizar estadísticas globales de respuestas enviadas
+            globalStats.responsesSent++;
+
+            // Registrar acceso a ruta
+            if (req.originalUrl) {
+              const routeKey = `${req.method} ${req.originalUrl}`;
+              if (!globalStats.routeAccesses.has(routeKey)) {
+                globalStats.routeAccesses.set(routeKey, 0);
+              }
+              globalStats.routeAccesses.set(routeKey, globalStats.routeAccesses.get(routeKey) + 1);
+            }
+
+            // Registrar hit al endpoint
+            const endpointKey = `${req.method} ${matchedRoute.route.path}`;
+            if (!globalStats.endpointHits.has(endpointKey)) {
+              globalStats.endpointHits.set(endpointKey, 0);
+            }
+            globalStats.endpointHits.set(endpointKey, globalStats.endpointHits.get(endpointKey) + 1);
+
             if (hooks) {
               hooks.doAction('route_handler_executed', matchedRoute, req, res);
             }

package/lib/mvc/viewEngine.js

@@ -274,7 +274,22 @@ 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);
+        
+        // Disparar hook después de cachear
+        if (this.hooks) {
+          this.hooks.doAction('view_cached', viewPath, contentToCache);
+        }
+      }
     }
 
     // Procesar el template con las variables
@@ -817,7 +832,17 @@ 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);
+    }
+    
     this.viewCache.clear();
+    
+    // Disparar hook después de limpiar el caché
+    if (this.hooks) {
+      this.hooks.doAction('view_cache_cleared');
+    }
   }
 }
 

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/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.5.8",
+  "description": "JERK Framework v2.5.8 - 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, and fixed routing issues with static and parametrized routes",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",