jerkjs 2.5.4 → 2.5.8

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.4",
-  "description": "JERK Framework v2.5.4 - 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",

package/@qaLoadModel/controllers/ProductController.js

@@ -1,143 +0,0 @@
-// controllers/ProductController.js
-const { ControllerBase } = require('../../index.js');
-
-class ProductController extends ControllerBase {
-  constructor() {
-    super();
-  }
-
-  // Método para mostrar la lista de productos
-  async index(req, res) {
-    try {
-      // Obtener el adaptador desde el modelManager en la solicitud
-      const adapter = req.modelManager?.getAdapter('memory') || null;
-      
-      // Cargar el modelo de productos con el adaptador
-      const productModel = await this.loadModel('ProductModel', {
-        adapter: adapter
-      });
-      
-      // Obtener todos los productos
-      const products = await productModel.getAllProducts();
-      
-      // Renderizar la vista con los datos
-      res.render('products/index', {
-        title: 'Lista de Productos',
-        products: products,
-        message: 'Productos disponibles en el sistema'
-      });
-    } catch (error) {
-      console.error('Error en ProductController.index:', error);
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-    }
-  }
-
-  // Método para mostrar un producto específico
-  async show(req, res) {
-    try {
-      // Obtener el adaptador desde el modelManager en la solicitud
-      const adapter = req.modelManager?.getAdapter('memory') || null;
-      
-      // Cargar el modelo de productos con el adaptador
-      const productModel = await this.loadModel('ProductModel', {
-        adapter: adapter
-      });
-      
-      // Obtener el ID de los parámetros
-      const id = req.params.id;
-      
-      // Obtener el producto específico
-      const product = await productModel.getProductById(id);
-      
-      if (!product) {
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Producto no encontrado' }));
-        return;
-      }
-      
-      // Renderizar la vista con los datos
-      res.render('products/show', {
-        title: `Producto #${id}`,
-        product: product
-      });
-    } catch (error) {
-      console.error('Error en ProductController.show:', error);
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-    }
-  }
-
-  // Método para crear un nuevo producto
-  async create(req, res) {
-    try {
-      // Obtener el adaptador desde el modelManager en la solicitud
-      const adapter = req.modelManager?.getAdapter('memory') || null;
-      
-      // Cargar el modelo de productos con el adaptador
-      const productModel = await this.loadModel('ProductModel', {
-        adapter: adapter
-      });
-      
-      // Obtener los datos del cuerpo de la solicitud
-      const productData = req.body;
-      
-      // Crear el nuevo producto
-      const productId = await productModel.createProduct(productData);
-      
-      // Responder con éxito
-      res.writeHead(201, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ 
-        success: true, 
-        id: productId,
-        message: 'Producto creado exitosamente'
-      }));
-    } catch (error) {
-      console.error('Error en ProductController.create:', error);
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-    }
-  }
-
-  // Método para buscar productos por categoría
-  async searchByCategory(req, res) {
-    try {
-      // Obtener el adaptador desde el modelManager en la solicitud
-      const adapter = req.modelManager?.getAdapter('memory') || null;
-      
-      // Cargar el modelo de productos con el adaptador
-      const productModel = await this.loadModel('ProductModel', {
-        adapter: adapter
-      });
-      
-      // Obtener la categoría de los parámetros de consulta
-      const category = req.query.category || '';
-      
-      // Buscar productos por categoría
-      const products = await productModel.getProductsByCategory(category);
-      
-      // Responder con los resultados
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ 
-        success: true,
-        results: products,
-        count: products.length
-      }));
-    } catch (error) {
-      console.error('Error en ProductController.searchByCategory:', error);
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-    }
-  }
-}
-
-// Crear instancia del controlador
-const productController = new ProductController();
-
-// Preservar el contexto 'this' para cada método
-productController.index = productController.index.bind(productController);
-productController.show = productController.show.bind(productController);
-productController.create = productController.create.bind(productController);
-productController.searchByCategory = productController.searchByCategory.bind(productController);
-
-module.exports = productController;

package/@qaLoadModel/controllers/UserController.js

@@ -1,143 +0,0 @@
-// controllers/UserController.js
-const { ControllerBase } = require('../../index.js');
-
-class UserController extends ControllerBase {
-  constructor() {
-    super();
-  }
-
-  // Método para mostrar la lista de usuarios
-  async index(req, res) {
-    try {
-      // Obtener el adaptador desde el modelManager en la solicitud
-      const adapter = req.modelManager?.getAdapter('memory') || null;
-      
-      // Cargar el modelo de usuarios con el adaptador
-      const userModel = await this.loadModel('UserModel', {
-        adapter: adapter
-      });
-
-      // Obtener todos los usuarios
-      const users = await userModel.getAllUsers();
-
-      // Renderizar la vista con los datos
-      res.render('users/index', {
-        title: 'Lista de Usuarios',
-        users: users,
-        message: 'Usuarios registrados en el sistema'
-      });
-    } catch (error) {
-      console.error('Error en UserController.index:', error);
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-    }
-  }
-
-  // Método para mostrar un usuario específico
-  async show(req, res) {
-    try {
-      // Obtener el adaptador desde el modelManager en la solicitud
-      const adapter = req.modelManager?.getAdapter('memory') || null;
-      
-      // Cargar el modelo de usuarios con el adaptador
-      const userModel = await this.loadModel('UserModel', {
-        adapter: adapter
-      });
-
-      // Obtener el ID de los parámetros
-      const id = req.params.id;
-
-      // Obtener el usuario específico
-      const user = await userModel.getUserById(id);
-
-      if (!user) {
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Usuario no encontrado' }));
-        return;
-      }
-
-      // Renderizar la vista con los datos
-      res.render('users/show', {
-        title: `Usuario #${id}`,
-        user: user
-      });
-    } catch (error) {
-      console.error('Error en UserController.show:', error);
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-    }
-  }
-
-  // Método para crear un nuevo usuario
-  async create(req, res) {
-    try {
-      // Obtener el adaptador desde el modelManager en la solicitud
-      const adapter = req.modelManager?.getAdapter('memory') || null;
-      
-      // Cargar el modelo de usuarios con el adaptador
-      const userModel = await this.loadModel('UserModel', {
-        adapter: adapter
-      });
-
-      // Obtener los datos del cuerpo de la solicitud
-      const userData = req.body;
-
-      // Crear el nuevo usuario
-      const userId = await userModel.createUser(userData);
-
-      // Responder con éxito
-      res.writeHead(201, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        success: true,
-        id: userId,
-        message: 'Usuario creado exitosamente'
-      }));
-    } catch (error) {
-      console.error('Error en UserController.create:', error);
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-    }
-  }
-
-  // Método para buscar usuarios por nombre
-  async search(req, res) {
-    try {
-      // Obtener el adaptador desde el modelManager en la solicitud
-      const adapter = req.modelManager?.getAdapter('memory') || null;
-      
-      // Cargar el modelo de usuarios con el adaptador
-      const userModel = await this.loadModel('UserModel', {
-        adapter: adapter
-      });
-
-      // Obtener el término de búsqueda de los parámetros de consulta
-      const name = req.query.name || '';
-
-      // Buscar usuarios por nombre
-      const users = await userModel.getUsersByName(name);
-
-      // Responder con los resultados
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        success: true,
-        results: users,
-        count: users.length
-      }));
-    } catch (error) {
-      console.error('Error en UserController.search:', error);
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-    }
-  }
-}
-
-// Crear instancia del controlador
-const userController = new UserController();
-
-// Preservar el contexto 'this' para cada método
-userController.index = userController.index.bind(userController);
-userController.show = userController.show.bind(userController);
-userController.create = userController.create.bind(userController);
-userController.search = userController.search.bind(userController);
-
-module.exports = userController;