jerkjs 2.5.0 → 2.5.2

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # CHANGELOG
 
+## v2.5.2 - 7 de febrero de 2026
+
+### Fixed
+- **Prioridad de enrutamiento corregida**: Se resolvió un problema crítico donde las rutas estáticas (prefijos) tenían prioridad sobre las rutas parametrizadas, lo que impedía que rutas como `/api/products/:id` funcionaran correctamente cuando existía una ruta estática como `/api`. El nuevo orden de prioridad es: 1) Rutas exactas → 2) Rutas parametrizadas → 3) Rutas estáticas.
+- **Funcionamiento de rutas parametrizadas en modo directorio**: Se corrigió el problema donde las rutas parametrizadas no funcionaban correctamente cuando se utilizaba el modo de carga de rutas desde directorio (RouteDirectoryLoader), afectando especialmente el sistema de colas de Qwen.
+- **Separación de responsabilidades en enrutamiento**: Se movió toda la lógica de enrutamiento a un componente especializado `RouteMatcher.js`, eliminando la duplicación de lógica entre `server.js` y `routeLoader.js`.
+
+### Changed
+- **Arquitectura de enrutamiento mejorada**: Se implementó un componente especializado `RouteMatcher.js` para encapsular toda la lógica de enrutamiento, siguiendo principios de separación de responsabilidades y mejorando la mantenibilidad del código.
+- **Compatibilidad mantenida**: Se mantuvo la compatibilidad hacia atrás con el modo archivo único, asegurando que no se introdujeran regresiones en funcionalidades existentes.
+
+## v2.5.1 - 7 de febrero de 2026
+
+### Fixed
+- **Manejo de directorios en rutas estáticas**: Se corrigió un error crítico donde el sistema de rutas estáticas intentaba leer directorios como si fueran archivos, causando el error `EISDIR: illegal operation on a directory, read`. La solución implementa una verificación explícita para determinar si la ruta es un directorio y en tal caso busca el archivo índice correspondiente en lugar de intentar leerlo como archivo.
+
+### Changed
+- **Mejora en el sistema de logging de errores**: Se actualizó el sistema de logging para registrar correctamente los detalles de los errores internos en el nivel adecuado, facilitando la depuración sin comprometer la seguridad
+
 ## v2.5.0 - 6 de febrero de 2026
 
 ### Added

package/README.md

@@ -1,4 +1,4 @@
-# JERK Framework v2.5.0
+# JERK Framework v2.5.1
 
 ![JERK Framework Logo](jerk.webp)
 
@@ -106,6 +106,11 @@ server.addRoute('GET', '/assets', {
 });
 ```
 
+## Novedades en v2.5.1
+
+### Corrección de rutas estáticas
+- **Solución de error crítico con directorios**: Se corrigió un error donde el sistema de rutas estáticas intentaba leer directorios como si fueran archivos, causando el error `EISDIR: illegal operation on a directory, read`. Ahora el sistema verifica explícitamente si una ruta es un directorio y en tal caso busca el archivo índice correspondiente.
+
 ## Carga de Rutas desde Múltiples Archivos (v2.5.0)
 
 Desde la versión 2.5.0, JERK Framework incluye el componente `RouteDirectoryLoader` que permite cargar rutas desde múltiples archivos JSON ubicados en un directorio específico. Esta funcionalidad mejora la organización y mantenibilidad de aplicaciones grandes al permitir dividir las rutas en varios archivos en lugar de tener un único archivo `routes.json`.

package/index.js

@@ -1,6 +1,6 @@
 /**
  * Punto de entrada del framework JERK
- * JERK Framework 2.5.0
+ * JERK Framework 2.5.1
  */
 
 // Mostrar mensaje de versión al iniciar

package/lib/core/securityEnhancedServer.js

@@ -464,10 +464,10 @@ class SecurityEnhancedServer {
         // Disparar hook después de procesar la solicitud (pero antes de next)
         this.hooks.doAction('post_request_processing', req, res);
       } catch (error) {
-        this.logger.error('Error en middleware de seguridad:', error.message);
+        // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
+        const { ErrorHandler } = require('../utils/errorHandler');
         if (!res.headersSent) {
-          res.writeHead(500, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+          ErrorHandler.handle(error, req, res, this.logger);
         }
       }
     };

package/lib/core/server.js

@@ -12,6 +12,7 @@ const path = require('path');
 const { Logger } = require('../utils/logger');
 const { ErrorHandler } = require('../utils/errorHandler');
 const { getMimeType } = require('../utils/mimeType');
+const RouteMatcher = require('../router/RouteMatcher');
 
 class APIServer {
   /**
@@ -47,8 +48,8 @@ class APIServer {
     this.logger = new Logger();
     this.server = null;
 
-    // Cache de expresiones regulares para rutas parametrizadas
-    this.routeRegexCache = new Map();
+    // Inicializar el componente de enrutamiento
+    this.routeMatcher = new RouteMatcher();
   }
 
   /**
@@ -117,15 +118,17 @@ class APIServer {
         const physicalPath = path.join(baseDir, normalizedPath);
 
         // Verificar si el archivo existe
+        let stats;
         try {
           await fs.promises.access(physicalPath);
+          stats = await fs.promises.stat(physicalPath);
         } catch (accessErr) {
           // Si no existe el archivo solicitado, verificar si es un directorio y buscar archivo índice
           const dirPath = path.join(baseDir, normalizedPath);
           try {
-            const stats = await fs.promises.stat(dirPath);
+            const dirStats = await fs.promises.stat(dirPath);
 
-            if (stats.isDirectory()) {
+            if (dirStats.isDirectory()) {
               // Buscar archivo índice
               for (const indexFile of staticConfig.index || ['index.html']) {
                 const indexPath = path.join(dirPath, indexFile);
@@ -188,6 +191,51 @@ class APIServer {
           }
         }
 
+        // Si la ruta existe pero es un directorio, buscar archivo índice
+        if (stats && stats.isDirectory()) {
+          const dirPath = physicalPath;
+          // Buscar archivo índice
+          for (const indexFile of staticConfig.index || ['index.html']) {
+            const indexPath = path.join(dirPath, indexFile);
+            try {
+              await fs.promises.access(indexPath);
+              // Disparar hook antes de servir archivo índice
+              if (hooks) {
+                hooks.doAction('serving_index_file', indexPath, req, res);
+              }
+
+              const fileContent = await fs.promises.readFile(indexPath);
+              const mimeType = getMimeType(indexPath);
+
+              res.setHeader('Content-Type', mimeType);
+
+              if (staticConfig.cacheControl) {
+                res.setHeader('Cache-Control', staticConfig.cacheControl);
+              }
+
+              res.writeHead(200);
+              res.end(fileContent);
+
+              // Disparar hook después de servir archivo
+              if (hooks) {
+                hooks.doAction('static_file_served', indexPath, req, res);
+              }
+              return;
+            } catch (e) {
+              continue; // Probar siguiente archivo índice
+            }
+          }
+
+          // Si es directorio pero no hay archivo índice
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Directorio no encontrado' }));
+
+          if (hooks) {
+            hooks.doAction('static_directory_no_index', dirPath, req, res);
+          }
+          return;
+        }
+
         // Disparar hook antes de leer archivo
         if (hooks) {
           hooks.doAction('before_reading_static_file', physicalPath, req, res);
@@ -231,8 +279,9 @@ class APIServer {
             hooks.doAction('static_file_access_denied', error.path, req, res);
           }
         } else {
-          res.writeHead(500, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+          // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
+          const { ErrorHandler } = require('../utils/errorHandler');
+          ErrorHandler.handle(error, req, res, this.logger);
 
           const hooks = require('../../index.js').hooks;
           if (hooks) {
@@ -375,10 +424,10 @@ class APIServer {
                 }
               }
             } catch (error) {
-              console.error('Error en el manejo de autenticación de sesión:', error);
+              // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
+              const { ErrorHandler } = require('../utils/errorHandler');
               if (!res.headersSent) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+                ErrorHandler.handle(error, req, res, this.logger);
               }
             }
           };
@@ -426,10 +475,10 @@ class APIServer {
                 }
               }
             } catch (error) {
-              console.error('Error en el manejo de autenticación:', error);
+              // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
+              const { ErrorHandler } = require('../utils/errorHandler');
               if (!res.headersSent) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+                ErrorHandler.handle(error, req, res, this.logger);
               }
             }
           };
@@ -474,117 +523,7 @@ class APIServer {
    * @returns {Object|null} - Objeto de ruta encontrado o null
    */
   findRoute(method, pathname) {
-    // Buscar ruta exacta primero
-    const exactMatch = this.routes.find(route =>
-      route.method === method && route.path === pathname
-    );
-
-    if (exactMatch) {
-      return {
-        route: exactMatch,
-        params: {}
-      };
-    }
-
-    // Buscar rutas estáticas (prefijos)
-    for (const route of this.routes) {
-      if (route.method !== method) continue;
-
-      // Para rutas estáticas, verificar si la ruta solicitada comienza con el prefijo de la ruta estática
-      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);
-        if (route.path === '/' || remainingPath === '' || remainingPath.startsWith('/')) {
-          return {
-            route: route,
-            params: {}
-          };
-        }
-      }
-    }
-
-    // Buscar rutas parametrizadas
-    for (const route of this.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);
-        return {
-          route: route,
-          params
-        };
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Convierte una ruta con parámetros a expresión regular
-   * @param {string} path - Ruta con posibles parámetros
-   * @returns {RegExp} - Expresión regular para la ruta
-   */
-  pathToRegex(path) {
-    // Verificar si ya está en caché
-    if (this.routeRegexCache.has(path)) {
-      return this.routeRegexCache.get(path);
-    }
-
-    // Lógica de escape de caracteres especiales
-    let escapedPath = '';
-    for (let i = 0; i < path.length; i++) {
-      const char = path[i];
-      if (char.match(/[.+?^${}()|[\]\\]/) && !(i > 0 && path[i-1] === ':')) {
-        escapedPath += '\\' + char;
-      } else {
-        escapedPath += char;
-      }
-    }
-    // Reemplazar parámetros :param con grupos de captura no greedy para evitar problemas de matching
-    const regexPath = escapedPath.replace(/:([a-zA-Z0-9_]+)/g, '([^/]+?)');
-    const regex = new RegExp(`^${regexPath}$`);
-
-    // Almacenar en caché
-    this.routeRegexCache.set(path, regex);
-    return regex;
-  }
-
-  /**
-   * Extrae los parámetros de una ruta parametrizada
-   * @param {string} routePath - Ruta con parámetros (ej. /users/:id)
-   * @param {string} actualPath - Ruta real solicitada
-   * @returns {Object} - Objeto con los parámetros extraídos
-   */
-  extractParams(routePath, actualPath) {
-    const params = {};
-
-    // Expresión regular para encontrar parámetros en la ruta
-    const paramNames = [];
-    const paramNameRegex = /:([a-zA-Z0-9_]+)/g;
-    let match;
-
-    while ((match = paramNameRegex.exec(routePath)) !== null) {
-      paramNames.push(match[1]);
-    }
-
-    // Crear expresión regular para extraer valores
-    const routeRegex = this.pathToRegex(routePath);
-    const values = actualPath.match(routeRegex);
-
-    if (values) {
-      // El primer elemento es la cadena completa, los demás son los valores capturados
-      for (let i = 0; i < paramNames.length; i++) {
-        if (values[i + 1]) {
-          params[paramNames[i]] = values[i + 1];
-        }
-      }
-    }
-
-    return params;
+    return this.routeMatcher.findRoute(this.routes, method, pathname);
   }
 
   /**
@@ -725,9 +664,9 @@ class APIServer {
                 hooks.doAction('view_rendered', viewName, data, req, res);
               }
             } catch (error) {
-              console.error('Error renderizando vista:', error);
-              res.writeHead(500, { 'Content-Type': 'application/json' });
-              res.end(JSON.stringify({ error: 'Error interno del servidor', details: error.message }));
+              // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
+              const { ErrorHandler } = require('../utils/errorHandler');
+              ErrorHandler.handle(error, req, res, this.logger);
 
               if (hooks) {
                 hooks.doAction('view_render_error', viewName, data, req, res, error);

package/lib/loader/routeDirectoryLoader.js

@@ -186,7 +186,7 @@ class RouteDirectoryLoader {
     // Verificar si ya existe una ruta con el mismo método y path
     if (this.routeMap.has(routeKey)) {
       const existingRouteInfo = this.routeMap.get(routeKey);
-      
+
       // Disparar hook antes de sobrescribir ruta
       const hooks = require('../../index.js').hooks;
       if (hooks) {
@@ -196,18 +196,24 @@ class RouteDirectoryLoader {
           server
         });
       }
-      
+
       // Mostrar mensaje de advertencia con colores
       console.log('\x1b[31m%s\x1b[0m', `[RUTA SOBREESCRITA] Archivo: ${existingRouteInfo.sourceFile}, Ruta: ${route.method.toUpperCase()} ${route.path}`);
       console.log('\x1b[33m%s\x1b[0m', `[RUTA ACTUAL] Archivo: ${sourceFile}, Ruta: ${route.method.toUpperCase()} ${route.path}`);
+      
+      // Actualizar la ruta en el mapa con la nueva información
+      this.routeMap.set(routeKey, {
+        route: { ...route },
+        sourceFile
+      });
+    } else {
+      // Agregar la ruta al mapa con su archivo de origen
+      this.routeMap.set(routeKey, {
+        route: { ...route },
+        sourceFile
+      });
     }
 
-    // Agregar la ruta al mapa con su archivo de origen
-    this.routeMap.set(routeKey, {
-      route: { ...route },
-      sourceFile
-    });
-
     // Cargar la ruta en el servidor
     const routeLoader = new RouteLoader();
     await routeLoader.loadSingleRoute(server, route);

package/lib/loader/routeLoader.js

@@ -6,6 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const RouteMatcher = require('../router/RouteMatcher');
 
 class RouteLoader {
   /**
@@ -13,6 +14,8 @@ class RouteLoader {
    */
   constructor() {
     this.loadedRoutes = [];
+    // Inicializar el componente de enrutamiento para uso en el loader si es necesario
+    this.routeMatcher = new RouteMatcher();
   }
 
   /**
@@ -201,10 +204,10 @@ class RouteLoader {
                   }
                 }
               } catch (error) {
-                console.error('Error en el manejo de autenticación de sesión:', error);
+                // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
+                const { ErrorHandler } = require('../utils/errorHandler');
                 if (!res.headersSent) {
-                  res.writeHead(500, { 'Content-Type': 'application/json' });
-                  res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+                  ErrorHandler.handle(error, req, res, server.logger || { error: (msg) => console.error(msg) });
                 }
               }
             };
@@ -244,10 +247,10 @@ class RouteLoader {
                   }
                 }
               } catch (error) {
-                console.error('Error en el manejo de autenticación:', error);
+                // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
+                const { ErrorHandler } = require('../utils/errorHandler');
                 if (!res.headersSent) {
-                  res.writeHead(500, { 'Content-Type': 'application/json' });
-                  res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+                  ErrorHandler.handle(error, req, res, server.logger || { error: (msg) => console.error(msg) });
                 }
               }
             };
@@ -296,27 +299,6 @@ class RouteLoader {
     }
   }
 
-  /**
-   * Convierte una ruta con parámetros a expresión regular
-   * @param {string} path - Ruta con posibles parámetros
-   * @returns {RegExp} - Expresión regular para la ruta
-   */
-  pathToRegex(path) {
-    // Escapar caracteres especiales de la ruta, excepto los parámetros
-    // Pero dejar : sin escapar ya que lo usaremos para identificar parámetros
-    let escapedPath = '';
-    for (let i = 0; i < path.length; i++) {
-      const char = path[i];
-      if (char.match(/[.+?^${}()|[\]\\]/) && !(i > 0 && path[i-1] === ':')) {
-        escapedPath += '\\' + char;
-      } else {
-        escapedPath += char;
-      }
-    }
-    // Reemplazar parámetros :param con grupos de captura
-    const regexPath = escapedPath.replace(/:([a-zA-Z0-9_]+)/g, '([^/]+)');
-    return new RegExp(`^${regexPath}$`);
-  }
 
   /**
    * Método para recargar rutas desde un archivo

package/lib/mvc/controllerBase.js

@@ -70,9 +70,9 @@ class ControllerBase {
       res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
       res.end(renderedView);
     } catch (error) {
-      console.error('Error renderizando vista:', error);
-      res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
-      res.end('Error interno del servidor');
+      // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
+      const { ErrorHandler } = require('../utils/errorHandler');
+      ErrorHandler.handle(error, this.req, res, { error: (msg) => console.error(msg) });
     }
   }
 

package/lib/router/RouteMatcher.js

@@ -0,0 +1,139 @@
+/**
+ * Componente especializado para la lógica de enrutado
+ * Implementación del componente router/RouteMatcher.js
+ * JERK Framework v2.1 - Separación de responsabilidades para enrutamiento
+ */
+
+class RouteMatcher {
+  /**
+   * Constructor del matcher de rutas
+   */
+  constructor() {
+    // Cache de expresiones regulares para rutas parametrizadas
+    this.routeRegexCache = new Map();
+  }
+
+  /**
+   * Método para encontrar una ruta coincidente
+   * @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
+    );
+
+    if (exactMatch) {
+      return {
+        route: exactMatch,
+        params: {}
+      };
+    }
+
+    // Buscar rutas parametrizadas antes que rutas estáticas (prefijos)
+    // Esto evita que rutas estáticas como /api capturen rutas parametrizadas como /api/users/:id
+    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);
+        return {
+          route: route,
+          params
+        };
+      }
+    }
+
+    // Buscar rutas estáticas (prefijos) - solo después de buscar rutas parametrizadas
+    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
+      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);
+        if (route.path === '/' || remainingPath === '' || remainingPath.startsWith('/')) {
+          return {
+            route: route,
+            params: {}
+          };
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Convierte una ruta con parámetros a expresión regular
+   * @param {string} path - Ruta con posibles parámetros
+   * @returns {RegExp} - Expresión regular para la ruta
+   */
+  pathToRegex(path) {
+    // Verificar si ya está en caché
+    if (this.routeRegexCache.has(path)) {
+      return this.routeRegexCache.get(path);
+    }
+
+    // Lógica de escape de caracteres especiales
+    let escapedPath = '';
+    for (let i = 0; i < path.length; i++) {
+      const char = path[i];
+      if (char.match(/[.+?^${}()|[\]\\]/) && !(i > 0 && path[i-1] === ':')) {
+        escapedPath += '\\' + char;
+      } else {
+        escapedPath += char;
+      }
+    }
+    // Reemplazar parámetros :param con grupos de captura no greedy para evitar problemas de matching
+    const regexPath = escapedPath.replace(/:([a-zA-Z0-9_]+)/g, '([^/]+?)');
+    const regex = new RegExp(`^${regexPath}$`);
+
+    // Almacenar en caché
+    this.routeRegexCache.set(path, regex);
+    return regex;
+  }
+
+  /**
+   * Extrae los parámetros de una ruta parametrizada
+   * @param {string} routePath - Ruta con parámetros (ej. /users/:id)
+   * @param {string} actualPath - Ruta real solicitada
+   * @returns {Object} - Objeto con los parámetros extraídos
+   */
+  extractParams(routePath, actualPath) {
+    const params = {};
+
+    // Expresión regular para encontrar parámetros en la ruta
+    const paramNames = [];
+    const paramNameRegex = /:([a-zA-Z0-9_]+)/g;
+    let match;
+
+    while ((match = paramNameRegex.exec(routePath)) !== null) {
+      paramNames.push(match[1]);
+    }
+
+    // Crear expresión regular para extraer valores
+    const routeRegex = this.pathToRegex(routePath);
+    const values = actualPath.match(routeRegex);
+
+    if (values) {
+      // El primer elemento es la cadena completa, los demás son los valores capturados
+      for (let i = 0; i < paramNames.length; i++) {
+        if (values[i + 1]) {
+          params[paramNames[i]] = values[i + 1];
+        }
+      }
+    }
+
+    return params;
+  }
+}
+
+module.exports = RouteMatcher;

package/lib/utils/errorHandler.js

@@ -99,13 +99,18 @@ class ErrorHandler {
         timestamp: new Date().toISOString()
       });
     } else {
-      console.error('Unknown Error:', {
-        message: error.message,
-        stack: error.stack,
-        url: req?.url,
-        method: req?.method,
-        timestamp: new Date().toISOString()
-      });
+      // Mostrar el stacktrace en color amarillo
+      const yellowColor = '\x1b[33m';
+      const resetColor = '\x1b[0m';
+      
+      console.error(`${yellowColor}======= STACKTRACE ERROR =======${resetColor}`);
+      console.error(`${yellowColor}Message: ${error.message}${resetColor}`);
+      console.error(`${yellowColor}URL: ${req?.url}${resetColor}`);
+      console.error(`${yellowColor}Method: ${req?.method}${resetColor}`);
+      console.error(`${yellowColor}Timestamp: ${new Date().toISOString()}${resetColor}`);
+      console.error(`${yellowColor}Stack:${resetColor}`);
+      console.error(`${yellowColor}${error.stack || 'No stack trace available'}${resetColor}`);
+      console.error(`${yellowColor}==============================${resetColor}`);
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jerkjs",
-  "version": "2.5.0",
-  "description": "JERK Framework v2.5.0 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, template engine, integration with qbuilderjs, complete MVC architecture with models, and enhanced route loading from directory",
+  "version": "2.5.2",
+  "description": "JERK Framework v2.5.2 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, template engine, integration with qbuilderjs, complete MVC architecture with models, and enhanced route loading from directory",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/qa/informe_qa_fix_enrutamiento.md

@@ -0,0 +1,93 @@
+# Informe QA: Sistema BlackCoffee con Fix de Enrutamiento
+
+## Resumen Ejecutivo
+
+El sistema BlackCoffee ha sido sometido a pruebas exhaustivas tras la implementación de un fix crítico para el enrutamiento de rutas parametrizadas. El problema que impedía el funcionamiento correcto de las rutas parametrizadas en modo directorio ha sido completamente resuelto.
+
+## Estado Anterior vs Actual
+
+### Antes del Fix
+- **Modo directorio (predeterminado)**: ❌ Rutas parametrizadas no funcionaban
+- **Modo archivo único**: ✅ Funcionaba correctamente
+- **Impacto**: Sistema de colas de Qwen no operativo en modo directorio
+
+### Después del Fix
+- **Modo directorio**: ✅ **TOTALMENTE OPERATIVO**
+- **Modo archivo único**: ✅ **CONTINÚA FUNCIONANDO CORRECTAMENTE**
+- **Impacto**: Sistema de colas de Qwen completamente funcional
+
+## Cambios Implementados
+
+### Arquitectura de Enrutamiento
+- Se implementó un componente especializado `RouteMatcher.js` para encapsular toda la lógica de enrutamiento
+- Se separaron claramente las responsabilidades entre componentes
+- Se centralizó la lógica de matching de rutas
+
+### Prioridad de Enrutamiento (Fix Principal)
+- **Antes**: Rutas estáticas (prefijos) tenían prioridad sobre rutas parametrizadas
+- **Después**: Rutas parametrizadas tienen prioridad sobre rutas estáticas
+- **Nuevo orden**: 1) Rutas exactas → 2) Rutas parametrizadas → 3) Rutas estáticas
+
+## Resultados de las Pruebas
+
+### Rutas Parametrizadas Funcionales
+| Ruta | Método | Controlador | Estado |
+|------|--------|-------------|---------|
+| `/api/products/:id` | GET | `getProductById` | ✅ Funcional |
+| `/api/qwen/result/:id` | GET | `getQwenResult` | ✅ Funcional |
+| `/api/queue/status/:id` | GET | `getJobStatus` | ✅ Funcional |
+| `/api/queue/jobs/:status` | GET | `getJobsByStatus` | ✅ Funcional |
+
+### Sistema de Colas de Qwen
+| Endpoint | Funcionalidad | Estado |
+|----------|---------------|---------|
+| `POST /api/qwen/queue` | Creación de trabajos | ✅ Funcional |
+| `GET /api/qwen/result/:id` | Consulta de resultados | ✅ Funcional |
+| Procesamiento completo | Trabajo de extremo a extremo | ✅ Funcional |
+
+### Validación de Parámetros
+- Extracción correcta de parámetros de rutas (ej: `:id`, `:status`)
+- Valores de parámetros correctamente pasados a controladores
+- Respuestas coherentes según valores de parámetros
+
+## Cobertura de Pruebas
+
+### Modo Directorio (Principal)
+- ✅ Carga de rutas desde múltiples archivos JSON
+- ✅ Registro correcto de todas las rutas
+- ✅ Prioridad correcta de rutas parametrizadas
+- ✅ Funcionamiento de rutas estáticas y dinámicas
+- ✅ Sistema de colas de Qwen operativo
+
+### Modo Archivo Único (Regresión)
+- ✅ Continuidad del funcionamiento previo
+- ✅ No regresiones introducidas
+- ✅ Compatibilidad hacia atrás mantenida
+
+## Métricas de Desempeño
+
+- **Tiempo de respuesta**: Dentro de rangos normales
+- **Consumo de memoria**: Estable
+- **Procesamiento de rutas**: Correcto en ambos modos
+- **Sistema de hooks**: Operativo sin interrupciones
+
+## Validación de Endpoints Registrados
+
+Se verificó que los 19 endpoints se registran correctamente en modo directorio, incluyendo:
+- 4 rutas parametrizadas funcionales
+- 10 rutas estáticas funcionales  
+- 5 rutas estáticas funcionales
+
+## Conclusión
+
+### ✅ ACEPTACIÓN TOTAL
+
+El fix implementado ha resuelto completamente el problema reportado. El sistema BlackCoffee ahora:
+
+1. **Opera correctamente en modo directorio** con todas las rutas parametrizadas funcionando
+2. **Mantiene compatibilidad** con el modo archivo único
+3. **Soporta completamente** el sistema de colas de Qwen
+4. **Sigue principios de arquitectura limpia** con separación de responsabilidades
+5. **No introduce regresiones** en funcionalidades existentes
+
+**Recomendación**: Aprobar el despliegue del fix a producción.