expressed-example-app 1.0.0 → 2.0.0

package/README.md

@@ -0,0 +1,87 @@
+# Express-Router-BDS Example Application
+
+This is a sample Express.js application demonstrating the usage of the `express-router-bds` routing system with custom hooks and advanced features.
+
+## Overview
+
+This example application showcases:
+
+- High-performance routing with `express-router-bDS`
+- JSON-based route configuration
+- Custom hook system implementation
+- Parameterized route handling
+- Directory-based route loading
+
+## Features
+
+- **Modular Route Configuration**: Routes defined in JSON files for easy maintenance
+- **Custom Hooks**: Comprehensive hook system with `pre_route_load`, `post_route_load`, `before_route_handler`, `after_route_handler`, `route_handler_error`, and more
+- **Parameterized Routes**: Support for dynamic routes like `/users/:id` and `/products/:category/:id`
+- **Extensible Architecture**: Easy to extend with custom middleware and hooks
+
+## Project Structure
+
+```
+express-app/
+├── app.js                 # Main application entry point
+├── hooks-config.js        # Base hook configurations
+├── hooks-personalizados.js # Custom hook implementations
+├── controllers/
+│   ├── mainController.js  # Home and init route handlers
+│   ├── productController.js # Product route handlers
+│   └── userController.js  # User route handlers
+├── routes/
+│   └── main-routes.json   # Route definitions in JSON format
+└── node_modules/
+    └── express-router-bds/ # Custom routing system
+```
+
+## Available Endpoints
+
+- `GET /` - Home page with welcome message
+- `GET /init` - Initialization endpoint
+- `GET /users/:id` - Get user by ID
+- `GET /products/:category/:id` - Get product by category and ID
+- `GET /test-hook` - Test endpoint for hook demonstration
+
+## Hook System
+
+The application demonstrates several types of hooks:
+
+- `pre_route_load` - Executes before loading routes from a file
+- `post_route_load` - Executes after loading routes from a file
+- `before_route_processing` - Executes before processing any route
+- `route_matched` - Executes when a matching route is found
+- `before_route_handler` - Executes before executing a route handler
+- `after_route_handler` - Executes after executing a route handler
+- `route_handler_error` - Executes when a route handler error occurs
+
+## Installation
+
+```bash
+npm install
+```
+
+## Usage
+
+Start the server:
+
+```bash
+npm start
+```
+
+The application will be available at `http://localhost:3000`
+
+## Testing
+
+Test the endpoints:
+
+```bash
+curl http://localhost:3000
+curl http://localhost:3000/users/123
+curl http://localhost:3000/products/electronics/456
+```
+
+## License
+
+This project is part of the `express-router-bds` ecosystem and follows the same licensing terms.

package/app.js

@@ -1,115 +1,62 @@
-/**
- * Aplicación principal
- * Integración de @hooked, @router y @queued con una arquitectura limpia
- */
-
 const express = require('express');
-const fs = require('fs');
-const path = require('path');
-const ExpressHooked = require('express-hooked');
 const ExpressRouterIntegration = require('express-router-bds');
-const ExpressQueueIntegration = require('express-queued');
-const AppHooks = require('./hooks/AppHooks');
-const { captureBodyMiddleware } = require('./middleware/bodyCapture');
+const RouteDirectoryLoader = require('express-router-bds/RouteDirectoryLoader');
+const AppHooks = require('./hooks-config');
+const HooksPersonalizados = require('./hooks-personalizados');
 
-// Crear la aplicación Express
 const app = express();
-const port = 3001;
-
-// Leer la configuración de rutas desde el archivo JSON
-const routesConfig = JSON.parse(fs.readFileSync(path.join(__dirname, 'config/routes.json'), 'utf8'));
+const PORT = process.env.PORT || 3000;
 
-// Inicializar el sistema de hooks
-const hooked = new ExpressHooked(app);
+// Crear instancia del router
+const routerIntegration = new ExpressRouterIntegration();
 
-// Inicializar el sistema de enrutamiento
-const router = new ExpressRouterIntegration();
+// Inicializar hooks y filtros
+const appHooks = new AppHooks(app, routerIntegration.getHooks());
 
-// Inicializar el sistema de colas
-const queueSystem = new ExpressQueueIntegration();
+// Inicializar hooks personalizados
+const hooksPersonalizados = new HooksPersonalizados(routerIntegration);
 
-// Registrar los hooks de la aplicación
-AppHooks.registerHooks(hooked);
 
-// Middleware para capturar el body
-app.use(captureBodyMiddleware);
+// Cargar rutas desde directorio
+const routeDirectoryLoader = new RouteDirectoryLoader();
 
-// Middleware para servir archivos estáticos
-app.use(express.static(path.join(__dirname, 'public')));
 
-// Cargar dinámicamente los controladores y registrar las rutas
-for (const route of routesConfig.routes) {
-  // Extraer el nombre del controlador y la acción
-  const [controllerName, actionName] = route.controller.split('.');
-  
-  // Construir la ruta del archivo del controlador
-  const controllerPath = path.join(__dirname, 'controllers', `${controllerName}.js`);
-  
-  // Verificar si el archivo del controlador existe
-  if (fs.existsSync(controllerPath)) {
-    // Importar el controlador
-    const Controller = require(controllerPath);
-    
-    // Verificar si la acción existe en el controlador
-    if (Controller[actionName]) {
-      // Registrar la ruta con el método HTTP, la ruta y el controlador
-      router.addRoute(route.method, route.path, (req, res) => {
-        // Disparar hook antes de ejecutar la acción
-        hooked.doAction('before_controller_action', req, res, route);
-        
-        // Disparar hook para mostrar información detallada de la solicitud
-        // Usar el body capturado en lugar del body original que puede estar vacío
-        if (req.capturedBody) {
-          req.body = req.capturedBody;
-        }
-        hooked.doAction('request_details_log', req, res, route);
-        
-        // Ejecutar la acción del controlador
-        Controller[actionName](req, res);
-        
-        // Disparar hook después de ejecutar la acción
-        hooked.doAction('after_controller_action', req, res, route);
-      });
-    } else {
-      console.error(`La acción "${actionName}" no existe en el controlador "${controllerName}"`);
-    }
-  } else {
-    console.error(`El archivo del controlador "${controllerPath}" no existe`);
+routerIntegration.addHook('route_matched', (matchedRoute, req, res) => {
+  console.log(`Ruta encontrada: ${matchedRoute.route.path}`);
+  if (matchedRoute.params && Object.keys(matchedRoute.params).length > 0) {
+    console.log(`Parámetros:`, matchedRoute.params);
   }
-}
-
-// Aplicar el middleware de colas para inyectar el sistema en las solicitudes
-app.use(queueSystem.queueMiddleware());
-
-// Aplicar el router a la aplicación
-router.applyToApp(app);
+});
 
-// Iniciar el sistema de colas
-queueSystem.start();
+// Cargar rutas desde el directorio
+routeDirectoryLoader.loadRoutesFromDirectory(routerIntegration, './routes')
+  .then(routes => {
+    console.log(`${routes.length} rutas cargadas desde directorio`);
+    // Mostrar las rutas que se han cargado
+    routes.forEach(route => {
+      console.log(`Ruta cargada: ${route.method} ${route.path}`);
+    });
+  })
+  .catch(error => {
+    console.error('Error cargando rutas desde directorio:', error.message);
+  });
 
-// Iniciar el sistema de hooks
-hooked.init();
+// Aplicar el router a la aplicación Express
+routerIntegration.applyToApp(app);
 
-// Middleware para manejo de errores
-app.use((err, req, res, next) => {
-  console.error('Error:', err);
-  res.status(500).json({
-    error: 'Ocurrió un error en el servidor',
-    message: err.message
-  });
+// Middleware para manejar errores 404
+app.use((req, res) => {
+  res.status(404).json({ error: 'Ruta no encontrada' });
 });
 
 // Iniciar el servidor
-app.listen(port, () => {
-  console.log(`Servidor corriendo en http://localhost:${port}`);
-  console.log('Módulos integrados:');
-  console.log('- @hooked: Sistema de hooks activo');
-  console.log('- @router: Sistema de enrutamiento activo');
-  console.log('- @queued: Sistema de colas activo');
-  
-  // Mostrar rutas registradas
-  console.log('\nRutas disponibles:');
-  routesConfig.routes.forEach(route => {
-    console.log(`${route.method} ${route.path} -> ${route.controller}.${route.action}`);
-  });
-});
+app.listen(PORT, () => {
+  console.log(`Servidor corriendo en el puerto ${PORT}`);
+  console.log('Endpoints disponibles:');
+  console.log('- GET /');
+  console.log('- GET /init');
+  console.log('- GET /users/:id');
+  console.log('- GET /products/:category/:id');
+});
+
+module.exports = app;

package/changelog-core-enrutador.md

@@ -0,0 +1,177 @@
+# Changelog Detallado: Modificaciones al Core de Express-Router-BDS
+
+## Archivo: `/node_modules/express-router-bds/ExpressRouter.js`
+
+### Cambio 1: Llamada al hook `before_route_processing`
+- **Fecha**: 15 de febrero de 2026
+- **Línea(s)**: 154
+- **Antes**:
+  ```javascript
+  this.hooks.doAction('before_route_processing', req, res, next);
+  ```
+- **Después**:
+  ```javascript
+  this.hooks.doAction('before_route_processing', req, res);
+  ```
+- **Motivo**: Evitar que el hook reciba el parámetro `next` para prevenir conflictos con el flujo normal de Express
+
+### Cambio 2: Manejo de headers en ejecución del handler
+- **Fecha**: 15 de febrero de 2026
+- **Líneas**: 185-187
+- **Antes**:
+  ```javascript
+  if (!res.headersSent) {
+    matchedRoute.route.handler(req, res, next);
+  } else {
+    console.warn('Headers ya fueron enviados, no se puede ejecutar el handler');
+  }
+  ```
+- **Después**:
+  ```javascript
+  if (!res.headersSent) {
+    // Añadir logging para depuración
+    console.log(`Ejecutando handler para ruta: ${req.method} ${req.url}`);
+    matchedRoute.route.handler(req, res, next);
+  } else {
+    console.warn('Headers ya fueron enviados, no se puede ejecutar el handler');
+    next();
+  }
+  ```
+- **Motivo**: Añadir logging para depuración y asegurar que se llame a `next()` si los headers ya han sido enviados
+
+### Cambio 3: Llamada a hooks de handler
+- **Fecha**: 15 de febrero de 2026
+- **Línea(s)**: 180
+- **Antes**:
+  ```javascript
+  this.hooks.doAction('before_route_handler', req, res, next);
+  ```
+- **Después**:
+  ```javascript
+  this.hooks.doAction('before_route_handler', req, res);
+  ```
+- **Motivo**: Consistencia con el manejo de hooks para evitar conflictos con `next()`
+
+### Cambio 4: Manejo de errores en handler
+- **Fecha**: 15 de febrero de 2026
+- **Línea(s)**: 193
+- **Antes**:
+  ```javascript
+  this.hooks.doAction('route_handler_error', error, req, res, next);
+  ```
+- **Después**:
+  ```javascript
+  this.hooks.doAction('route_handler_error', error, req, res);
+  ```
+- **Motivo**: Consistencia con el manejo de hooks para evitar conflictos con `next()`
+
+## Archivo: `/node_modules/express-router-bds/RouteLoader.js`
+
+### Cambio 1: Manejo seguro de headers en handlers con contentType
+- **Fecha**: 15 de febrero de 2026
+- **Líneas**: 178-195
+- **Antes**:
+  ```javascript
+  // Ejecutar el handler original
+  try {
+    if (handler.constructor.name === 'AsyncFunction') {
+      await handler(req, res, next);
+    } else {
+      handler(req, res, next);
+    }
+  } catch (error) {
+    // Si ocurre un error, asegurarse de no intentar enviar headers otra vez
+    if (!res.headersSent) {
+      next(error);
+    } else {
+      console.error('Error en el handler:', error);
+    }
+  }
+  ```
+- **Después**:
+  ```javascript
+  // Ejecutar el handler original solo si no se han enviado headers aún
+  if (!res.headersSent) {
+    try {
+      if (handler.constructor.name === 'AsyncFunction') {
+        await handler(req, res, next);
+      } else {
+        handler(req, res, next);
+      }
+    } catch (error) {
+      // Si ocurre un error, asegurarse de no intentar enviar headers otra vez
+      if (!res.headersSent) {
+        next(error);
+      } else {
+        console.error('Error en el handler:', error);
+      }
+    }
+  }
+  ```
+- **Motivo**: Asegurar que los handlers no se ejecuten si los headers ya han sido enviados
+
+### Cambio 2: Eliminación de wrapper adicional
+- **Fecha**: 15 de febrero de 2026
+- **Líneas**: 197-217
+- **Antes**:
+  ```javascript
+  // Crear un handler que envuelva completamente la lógica para prevenir doble ejecución
+  const wrappedHandler = async (req, res, next) => {
+    // Verificar que no se hayan enviado headers aún
+    if (res.headersSent) {
+      return;
+    }
+
+    // Ejecutar el handler final
+    try {
+      await finalHandler(req, res, next);
+    } catch (error) {
+      if (!res.headersSent) {
+        next(error);
+      } else {
+        console.error('Error en el handler:', error);
+      }
+    }
+  };
+
+  // Agregar la ruta con el handler envuelto
+  routerIntegration.addRoute(route.method, route.path, wrappedHandler);
+  ```
+- **Después**:
+  ```javascript
+  // Agregar la ruta con el handler final (sin doble wrapper)
+  // Asegurarse de que el handler es correcto
+  routerIntegration.addRoute(route.method, route.path, finalHandler);
+  ```
+- **Motivo**: Eliminar wrapper redundante que podría causar problemas de ejecución doble
+
+## Archivo: `/node_modules/express-router-bds/RouteMatcher.js`
+
+### Cambio 1: Mejora en la conversión de rutas a expresiones regulares
+- **Fecha**: 15 de febrero de 2026
+- **Líneas**: 213-225
+- **Antes**:
+  ```javascript
+  // 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;
+    }
+  }
+  ```
+- **Después**: (Sin cambios, ya que no se modificó este archivo directamente)
+
+## Resumen de Impacto
+
+Los cambios realizados al core de `express-router-bds` se enfocaron principalmente en:
+
+1. **Evitar conflictos con el parámetro `next`** en las llamadas a hooks
+2. **Mejorar la seguridad en el manejo de headers** para prevenir el error `ERR_HTTP_HEADERS_SENT`
+3. **Eliminar wrappers redundantes** que podían causar ejecuciones dobles de handlers
+4. **Agregar verificaciones adicionales** para asegurar que los handlers solo se ejecuten cuando sea seguro hacerlo
+
+Estos cambios resolvieron el problema fundamental donde las rutas se identificaban pero los handlers no se ejecutaban, permitiendo que la aplicación funcione correctamente.

package/controllers/mainController.js

@@ -0,0 +1,34 @@
+// controllers/mainController.js
+// Controlador principal de la aplicación
+
+class MainController {
+  /**
+   * Maneja la ruta raíz
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  home(req, res) {
+    if (!res.headersSent) {
+      res.json({
+        message: '¡Bienvenido a la aplicación Express con Router-BDS!',
+        timestamp: new Date().toISOString()
+      });
+    } else {
+      console.log('Headers ya fueron enviados en home handler');
+    }
+  }
+
+  /**
+   * Maneja la ruta de inicialización
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  init(req, res) {
+    res.json({ 
+      message: 'Aplicación inicializada correctamente con Router-BDS',
+      status: 'success'
+    });
+  }
+}
+
+module.exports = new MainController();

package/controllers/productController.js

@@ -0,0 +1,22 @@
+// controllers/productController.js
+// Controlador para gestionar productos
+
+class ProductController {
+  /**
+   * Obtiene un producto por categoría e ID
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  getProduct(req, res) {
+    const category = req.params.category;
+    const productId = req.params.id;
+    res.json({ 
+      message: `Obteniendo producto de la categoría "${category}" con ID: ${productId}`,
+      category: category,
+      productId: productId,
+      timestamp: new Date().toISOString()
+    });
+  }
+}
+
+module.exports = new ProductController();

package/controllers/userController.js

@@ -0,0 +1,20 @@
+// controllers/userController.js
+// Controlador para gestionar usuarios
+
+class UserController {
+  /**
+   * Obtiene un usuario por ID
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  getUser(req, res) {
+    const userId = req.params.id;
+    res.json({ 
+      message: `Obteniendo información del usuario con ID: ${userId}`,
+      userId: userId,
+      timestamp: new Date().toISOString()
+    });
+  }
+}
+
+module.exports = new UserController();

package/documentacion-bug-enrutamiento.md

@@ -0,0 +1,114 @@
+# Documento de Análisis: Bug de Enrutamiento en Express-Router-BDS
+
+## Descripción del Problema
+
+La aplicación Express con el sistema de enrutamiento personalizado `express-router-bds` presentaba un fallo crítico donde:
+
+- Las rutas se identificaban correctamente en el sistema
+- El log mostraba mensajes como "Ruta encontrada: /"
+- Sin embargo, los handlers correspondientes no se ejecutaban
+- El sistema respondía con "Ruta no encontrada" para todas las rutas válidas
+- Aparecía el error `ERR_HTTP_HEADERS_SENT: Cannot set headers after they are sent to the client`
+
+## Análisis Técnico
+
+### Componentes Involucrados
+
+1. **ExpressRouter.js** - Middleware principal de enrutamiento
+2. **hooks-config.js** - Configuración de hooks personalizados
+3. **RouteMatcher.js** - Sistema de coincidencia de rutas
+4. **RouteLoader.js** - Cargador de rutas desde archivos JSON
+
+### Causa Raíz
+
+El problema se originó por una **interacción incorrecta entre el sistema de hooks y el flujo normal de Express**:
+
+1. El hook `before_route_processing` se definía con 3 parámetros: `(req, res, next)`
+2. Este hook se registraba en `hooks-config.js` y se llamaba en `ExpressRouter.js`
+3. El hook contenía una llamada a `next()`, lo que causaba que `next()` se ejecutara dos veces:
+   - Una vez por el hook
+   - Otra vez por el flujo normal del middleware
+4. Esto provocaba que los headers se enviaran antes de tiempo
+5. Cuando el sistema intentaba ejecutar el handler real, fallaba porque los headers ya habían sido enviados
+
+### Flujo de Ejecución Defectuoso
+
+```javascript
+// En ExpressRouter.js
+this.hooks.doAction('before_route_processing', req, res, next);
+
+// En hooks-config.js
+this.hooks.addAction('before_route_processing', (req, res, next) => {
+  console.log(`[HOOK-ACTIVADO] Procesando ruta: ${req.method} ${req.url}`);
+  next(); // ← ESTO CAUSABA EL PROBLEMA
+});
+```
+
+## Solución Implementada
+
+### Cambios Realizados
+
+#### 1. En `ExpressRouter.js`
+
+```javascript
+// ANTES
+this.hooks.doAction('before_route_processing', req, res, next);
+
+// DESPUÉS  
+this.hooks.doAction('before_route_processing', req, res);
+```
+
+#### 2. En `hooks-config.js`
+
+```javascript
+// ANTES
+this.hooks.addAction('before_route_processing', (req, res, next) => {
+  console.log(`[HOOK-ACTIVADO] Procesando ruta: ${req.method} ${req.url}`);
+  next(); // ← ESTA LLAMADA CAUSABA EL CONFLICTO
+});
+
+// DESPUÉS
+this.hooks.addAction('before_route_processing', (req, res, next) => {
+  console.log(`[HOOK-ACTIVADO] Procesando ruta: ${req.method} ${req.url}`);
+  // next(); ← COMENTADO PARA EVITAR DUPLICACIÓN
+});
+```
+
+#### 3. En `mainController.js` (como medida preventiva)
+
+```javascript
+home(req, res) {
+  if (!res.headersSent) {
+    res.json({
+      message: '¡Bienvenido a la aplicación Express con Router-BDS!',
+      timestamp: new Date().toISOString()
+    });
+  } else {
+    console.log('Headers ya fueron enviados en home handler');
+  }
+}
+```
+
+## Resultado
+
+Después de aplicar la solución:
+
+✅ **Todas las rutas estáticas funcionan** (`/`, `/init`)  
+✅ **Todas las rutas parametrizadas funcionan** (`/users/:id`, `/products/:category/:id`)  
+✅ **No hay más errores de headers duplicados**  
+✅ **Los parámetros de ruta se pasan correctamente**  
+✅ **El sistema de hooks sigue funcionando para logging**  
+
+## Lecciones Aprendidas
+
+1. **Separación de responsabilidades**: Los hooks deben usarse para extensibilidad, no para controlar el flujo principal
+2. **Cuidado con `next()`**: Llamar a `next()` en múltiples lugares puede causar efectos colaterales
+3. **Importancia de pruebas**: Este tipo de error puede pasar desapercibido sin pruebas adecuadas
+4. **Logging vs. Control de Flujo**: Los hooks de logging no deben alterar el flujo de la aplicación
+
+## Recomendaciones
+
+- Implementar pruebas unitarias para el sistema de enrutamiento
+- Documentar claramente la responsabilidad de cada hook
+- Considerar el uso de un sistema de middleware más explícito para evitar confusiones
+- Añadir validaciones para prevenir llamadas duplicadas a `next()`

package/hooks-config.js

@@ -0,0 +1,42 @@
+// hooks-config.js
+// Archivo de configuración para los hooks y filtros de la aplicación
+
+class AppHooks {
+  constructor(expressApp, hookedInstance) {
+    this.app = expressApp;
+    this.hooks = hookedInstance;
+    
+    this.initHooks();
+    this.initFilters();
+  }
+  
+  initHooks() {
+    // Hook para antes de procesar cualquier ruta - SOLO PARA LOGGING
+    this.hooks.addAction('before_route_processing', (req, res, next) => {
+      console.log(`[HOOK-ACTIVADO] Procesando ruta: ${req.method} ${req.url}`);
+      // IMPORTANTE: No llamar a next() aquí, eso es responsabilidad del middleware
+      // next(); // Comentado para evitar la duplicación de next()
+    }, 10, 3); // Prioridad 10 y acepta 3 argumentos
+  }
+  
+  initFilters() {
+    // Filtro para modificar el mensaje de bienvenida
+    this.hooks.addFilter('welcome_message', (message, req) => {
+      // Agregar información del usuario o fecha al mensaje
+      const timestamp = new Date().toLocaleTimeString();
+      return `${message} - Petición recibida a las ${timestamp}`;
+    }, 10, 2); // Prioridad 10 y acepta 2 argumentos
+  }
+  
+  // Método para aplicar un filtro específico
+  applyWelcomeMessageFilter(message, req) {
+    return this.hooks.applyFilters('welcome_message', message, req);
+  }
+  
+  // Método para ejecutar un hook específico
+  executeRootBeforeHook(req, res, next) {
+    this.hooks.doAction('root:before', req, res, next);
+  }
+}
+
+module.exports = AppHooks;

package/hooks-personalizados.js

@@ -0,0 +1,54 @@
+// hooks-personalizados.js
+// Archivo de hooks personalizados para la aplicación
+
+class HooksPersonalizados {
+  constructor(routerIntegration) {
+    this.routerIntegration = routerIntegration;
+    this.initHooks();
+  }
+
+  initHooks() {
+    // Hook que se ejecuta antes de cargar rutas desde un archivo
+    this.routerIntegration.addHook('pre_route_load', (filePath, routerIntegration) => {
+      console.log(`[PRE_ROUTE_LOAD] Iniciando carga de rutas desde: ${filePath}`);
+    }, 10, 2);
+
+    // Hook que se ejecuta después de cargar rutas desde un archivo
+    this.routerIntegration.addHook('post_route_load', (routes, routerIntegration) => {
+      console.log(`[POST_ROUTE_LOAD] Se cargaron ${routes.length} rutas exitosamente`);
+      routes.forEach((route, index) => {
+        console.log(`[POST_ROUTE_LOAD] Ruta ${index + 1}: ${route.method} ${route.path}`);
+      });
+    }, 10, 2);
+
+    // Hook que se ejecuta antes de procesar cualquier ruta
+    this.routerIntegration.addHook('before_route_processing', (req, res) => {
+      console.log(`[BEFORE_ROUTE_PROCESSING] Procesando ruta: ${req.method} ${req.url}`);
+    }, 10, 2);
+
+    // Hook que se ejecuta cuando se encuentra una ruta coincidente
+    this.routerIntegration.addHook('route_matched', (matchedRoute, req, res) => {
+      console.log(`[ROUTE_MATCHED] Ruta encontrada: ${matchedRoute.route.path}`);
+      if (matchedRoute.params && Object.keys(matchedRoute.params).length > 0) {
+        console.log(`[ROUTE_MATCHED] Parámetros:`, matchedRoute.params);
+      }
+    }, 10, 3);
+
+    // Hook que se ejecuta antes de ejecutar un handler de ruta
+    this.routerIntegration.addHook('before_route_handler', (req, res) => {
+      console.log(`[BEFORE_ROUTE_HANDLER] Antes de ejecutar handler para: ${req.method} ${req.url}`);
+    }, 10, 2);
+
+    // Hook que se ejecuta después de ejecutar un handler de ruta
+    this.routerIntegration.addHook('after_route_handler', (req, res) => {
+      console.log(`[AFTER_ROUTE_HANDLER] Después de ejecutar handler para: ${req.method} ${req.url}`);
+    }, 10, 2);
+
+    // Hook que se ejecuta cuando ocurre un error en un handler de ruta
+    this.routerIntegration.addHook('route_handler_error', (error, req, res) => {
+      console.log(`[ROUTE_HANDLER_ERROR] Error en handler para: ${req.method} ${req.url}`, error.message);
+    }, 10, 3);
+  }
+}
+
+module.exports = HooksPersonalizados;

package/package.json

@@ -1,58 +1,19 @@
 {
   "name": "expressed-example-app",
-  "version": "1.0.0",
-  "description": "Example application integrating @hooked, @router and @queued",
+  "version": "2.0.0",
+  "description": "",
   "main": "app.js",
   "scripts": {
     "start": "node app.js",
-    "dev": "nodemon app.js"
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
+  "keywords": ["web express example"],
+  "author": "BDS",
+  "license": "ISC",
   "dependencies": {
     "express": "^4.22.1",
-    "express-hooked": "^1.0.1",
+    "express-hooked": "^1.0.2",
     "express-queued": "^1.0.0",
-    "express-router-bds": "^1.0.0"
-  },
-  "keywords": [
-    "express",
-    "hooks",
-    "middleware",
-    "router",
-    "routing",
-    "queues",
-    "queue-system",
-    "hook-system",
-    "event-driven",
-    "plugin-architecture",
-    "modular",
-    "scalable",
-    "example",
-    "demo",
-    "boilerplate",
-    "framework",
-    "web-framework",
-    "api",
-    "rest-api",
-    "microservices",
-    "async",
-    "asynchronous",
-    "background-jobs",
-    "task-queue",
-    "express-plugins",
-    "express-middleware",
-    "nodejs",
-    "javascript",
-    "backend",
-    "server"
-  ],
-  "author": "Benjamin Sanchez Cardenas",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://gitlab.com/bytedogssyndicate1/expressed-example-app.git"
-  },
-  "bugs": {
-    "url": "https://gitlab.com/bytedogssyndicate1/expressed-example-app/issues"
-  },
-  "homepage": "https://gitlab.com/bytedogssyndicate1/expressed-example-app#readme"
+    "express-router-bds": "^1.1.1"
+  }
 }

package/routes/main-routes.json

@@ -0,0 +1,37 @@
+[
+  {
+    "method": "GET",
+    "path": "/",
+    "controller": "./controllers/mainController",
+    "handler": "home",
+    "contentType": "application/json"
+  },
+  {
+    "method": "GET",
+    "path": "/init",
+    "controller": "./controllers/mainController",
+    "handler": "init",
+    "contentType": "application/json"
+  },
+  {
+    "method": "GET",
+    "path": "/users/:id",
+    "controller": "./controllers/userController",
+    "handler": "getUser",
+    "contentType": "application/json"
+  },
+  {
+    "method": "GET",
+    "path": "/products/:category/:id",
+    "controller": "./controllers/productController",
+    "handler": "getProduct",
+    "contentType": "application/json"
+  },
+  {
+    "method": "GET",
+    "path": "/test-hook",
+    "controller": "./controllers/mainController",
+    "handler": "home",
+    "contentType": "application/json"
+  }
+]

package/test-hooks.js

@@ -0,0 +1,31 @@
+// test-hooks.js
+// Script para probar los hooks pre_route_load y post_route_load
+
+const ExpressRouterIntegration = require('express-router-bds');
+const RouteLoader = require('express-router-bds/RouteLoader');
+const HooksPersonalizados = require('./hooks-personalizados');
+
+async function testHooks() {
+  console.log('Iniciando prueba de hooks pre_route_load y post_route_load...');
+  
+  // Crear instancia del router
+  const routerIntegration = new ExpressRouterIntegration();
+  
+  // Inicializar hooks personalizados
+  const hooksPersonalizados = new HooksPersonalizados(routerIntegration);
+  
+  // Crear instancia de RouteLoader
+  const routeLoader = new RouteLoader();
+  
+  try {
+    // Cargar rutas desde el archivo de prueba
+    console.log('\nCargando rutas desde test-routes.json...\n');
+    const routes = await routeLoader.loadRoutes(routerIntegration, './test-routes.json');
+    
+    console.log(`\nResultado: ${routes.length} rutas cargadas exitosamente`);
+  } catch (error) {
+    console.error('Error al cargar rutas:', error.message);
+  }
+}
+
+testHooks();

package/test-routes.json

@@ -0,0 +1,9 @@
+[
+  {
+    "method": "GET",
+    "path": "/test-hook",
+    "controller": "./controllers/mainController",
+    "handler": "home",
+    "contentType": "application/json"
+  }
+]

package/config/routes.json

@@ -1,70 +0,0 @@
-{
-  "routes": [
-    {
-      "method": "GET",
-      "path": "/",
-      "controller": "HomeController.index",
-      "action": "index"
-    },
-    {
-      "method": "GET",
-      "path": "/users",
-      "controller": "UserController.list",
-      "action": "list"
-    },
-    {
-      "method": "GET",
-      "path": "/users/:id",
-      "controller": "UserController.show",
-      "action": "show"
-    },
-    {
-      "method": "POST",
-      "path": "/users",
-      "controller": "UserController.create",
-      "action": "create"
-    },
-    {
-      "method": "PUT",
-      "path": "/users/:id",
-      "controller": "UserController.update",
-      "action": "update"
-    },
-    {
-      "method": "DELETE",
-      "path": "/users/:id",
-      "controller": "UserController.destroy",
-      "action": "destroy"
-    },
-    {
-      "method": "GET",
-      "path": "/products",
-      "controller": "ProductController.list",
-      "action": "list"
-    },
-    {
-      "method": "GET",
-      "path": "/products/:id",
-      "controller": "ProductController.show",
-      "action": "show"
-    },
-    {
-      "method": "POST",
-      "path": "/products",
-      "controller": "ProductController.create",
-      "action": "create"
-    },
-    {
-      "method": "GET",
-      "path": "/queue/status",
-      "controller": "QueueController.status",
-      "action": "status"
-    },
-    {
-      "method": "GET",
-      "path": "/endpoints",
-      "controller": "EndpointController.listEndpoints",
-      "action": "listEndpoints"
-    }
-  ]
-}

package/controllers/EndpointController.js

@@ -1,43 +0,0 @@
-/**
- * Controlador de endpoints
- */
-class EndpointController {
-  /**
-   * Lista todos los endpoints disponibles
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static listEndpoints(req, res) {
-    // El sistema de hooks será utilizado para obtener la lista de endpoints
-    if (req.app.locals.hooks) {
-      // Simular la recopilación de endpoints desde el sistema de rutas
-      const routes = [
-        { method: 'GET', path: '/', description: 'Inicio de la aplicación' },
-        { method: 'GET', path: '/users', description: 'Lista todos los usuarios' },
-        { method: 'GET', path: '/users/:id', description: 'Muestra un usuario específico' },
-        { method: 'POST', path: '/users', description: 'Crea un nuevo usuario' },
-        { method: 'PUT', path: '/users/:id', description: 'Actualiza un usuario' },
-        { method: 'DELETE', path: '/users/:id', description: 'Elimina un usuario' },
-        { method: 'GET', path: '/products', description: 'Lista todos los productos' },
-        { method: 'GET', path: '/products/:id', description: 'Muestra un producto específico' },
-        { method: 'POST', path: '/products', description: 'Crea un nuevo producto' },
-        { method: 'GET', path: '/queue/status', description: 'Estado del sistema de colas' },
-        { method: 'GET', path: '/endpoints', description: 'Lista todos los endpoints disponibles' }
-      ];
-      
-      // Permitir que los hooks modifiquen la lista de endpoints
-      const processedEndpoints = req.app.locals.hooks.applyFilters('endpoints_list', routes);
-      
-      res.json({
-        message: 'Lista de endpoints disponibles',
-        endpoints: processedEndpoints
-      });
-    } else {
-      res.status(500).json({
-        error: 'Sistema de hooks no disponible'
-      });
-    }
-  }
-}
-
-module.exports = EndpointController;

package/controllers/HomeController.js

@@ -1,19 +0,0 @@
-/**
- * Controlador de inicio
- */
-class HomeController {
-  /**
-   * Acción de inicio
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static index(req, res) {
-    res.json({
-      message: 'Bienvenido a la aplicación de ejemplo',
-      version: '1.0.0',
-      timestamp: new Date().toISOString()
-    });
-  }
-}
-
-module.exports = HomeController;

package/controllers/ProductController.js

@@ -1,47 +0,0 @@
-/**
- * Controlador de productos
- */
-class ProductController {
-  /**
-   * Lista todos los productos
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static list(req, res) {
-    res.json({
-      message: 'Lista de productos',
-      products: [
-        { id: 1, name: 'Laptop', price: 999.99 },
-        { id: 2, name: 'Mouse', price: 29.99 }
-      ]
-    });
-  }
-
-  /**
-   * Muestra un producto específico
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static show(req, res) {
-    const productId = req.params.id;
-    res.json({
-      message: `Información del producto ${productId}`,
-      product: { id: productId, name: `Product ${productId}`, price: 19.99 }
-    });
-  }
-
-  /**
-   * Crea un nuevo producto
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static create(req, res) {
-    const productData = req.body;
-    res.status(201).json({
-      message: 'Producto creado exitosamente',
-      product: { id: Date.now(), ...productData }
-    });
-  }
-}
-
-module.exports = ProductController;

package/controllers/QueueController.js

@@ -1,26 +0,0 @@
-/**
- * Controlador del sistema de colas
- */
-class QueueController {
-  /**
-   * Obtiene el estado del sistema de colas
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static status(req, res) {
-    // El sistema de colas será inyectado por el middleware
-    if (req.queueSystem) {
-      const status = req.queueSystem.getStatus();
-      res.json({
-        message: 'Estado del sistema de colas',
-        status: status
-      });
-    } else {
-      res.status(500).json({
-        error: 'Sistema de colas no disponible'
-      });
-    }
-  }
-}
-
-module.exports = QueueController;

package/controllers/UserController.js

@@ -1,73 +0,0 @@
-/**
- * Controlador de usuarios
- */
-class UserController {
-  /**
-   * Lista todos los usuarios
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static list(req, res) {
-    res.json({
-      message: 'Lista de usuarios',
-      users: [
-        { id: 1, name: 'John Doe', email: 'john@example.com' },
-        { id: 2, name: 'Jane Smith', email: 'jane@example.com' }
-      ]
-    });
-  }
-
-  /**
-   * Muestra un usuario específico
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static show(req, res) {
-    const userId = req.params.id;
-    res.json({
-      message: `Información del usuario ${userId}`,
-      user: { id: userId, name: `User ${userId}`, email: `user${userId}@example.com` }
-    });
-  }
-
-  /**
-   * Crea un nuevo usuario
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static create(req, res) {
-    const userData = req.body;
-    res.status(201).json({
-      message: 'Usuario creado exitosamente',
-      user: { id: Date.now(), ...userData }
-    });
-  }
-
-  /**
-   * Actualiza un usuario
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static update(req, res) {
-    const userId = req.params.id;
-    const userData = req.body;
-    res.json({
-      message: `Usuario ${userId} actualizado`,
-      user: { id: userId, ...userData }
-    });
-  }
-
-  /**
-   * Elimina un usuario
-   * @param {Object} req - Objeto de solicitud
-   * @param {Object} res - Objeto de respuesta
-   */
-  static destroy(req, res) {
-    const userId = req.params.id;
-    res.json({
-      message: `Usuario ${userId} eliminado`
-    });
-  }
-}
-
-module.exports = UserController;

package/hooks/AppHooks.js

@@ -1,60 +0,0 @@
-/**
- * Archivo de hooks para la aplicación
- * Define todos los hooks utilizados en la aplicación
- */
-
-class AppHooks {
-  /**
-   * Registra todos los hooks de la aplicación
-   * @param {ExpressHooked} hooked - Instancia del sistema de hooks
-   */
-  static registerHooks(hooked) {
-    // Hook para registrar información cuando comienza una solicitud
-    hooked.addAction('request_started', (req, res, next) => {
-      console.log(`[${new Date().toISOString()}] Nueva solicitud: ${req.method} ${req.url}`);
-      next();
-    });
-
-    // Hook para registrar información cuando se procesa una solicitud
-    hooked.addAction('request_processed', (req, res) => {
-      console.log(`[${new Date().toISOString()}] Solicitud procesada: ${req.method} ${req.url}`);
-    });
-
-    // Hook para registrar información detallada de cada solicitud
-    hooked.addAction('request_details_log', (req, res, routeInfo) => {
-      console.log(`\n--- Información de la Solicitud (mediante hook) ---`);
-      console.log(`Fecha/Hora: ${new Date().toISOString()}`);
-      console.log(`Método HTTP: ${req.method}`);
-      console.log(`Ruta: ${req.url}`);
-      if (routeInfo) {
-        console.log(`Ruta definida: ${routeInfo.method} ${routeInfo.path}`);
-        console.log(`Controlador: ${routeInfo.controller}`);
-        console.log(`Acción: ${routeInfo.action}`);
-      }
-      console.log(`IP Cliente: ${req.ip}`);
-      console.log(`Headers:`, req.headers);
-      if (Object.keys(req.params).length > 0) {
-        console.log(`Parámetros:`, req.params);
-      }
-      if (Object.keys(req.query).length > 0) {
-        console.log(`Query params:`, req.query);
-      }
-      if (req.body && Object.keys(req.body).length > 0) {
-        console.log(`Body:`, req.body);
-      }
-      console.log(`-----------------------------\n`);
-    });
-
-    // Hook para filtrar y modificar la lista de endpoints
-    hooked.addFilter('endpoints_list', (endpoints) => {
-      // Agregar información adicional a la lista de endpoints
-      return endpoints.map(endpoint => ({
-        ...endpoint,
-        addedBy: 'hook-system',
-        timestamp: new Date().toISOString()
-      }));
-    });
-  }
-}
-
-module.exports = AppHooks;

package/middleware/bodyCapture.js

@@ -1,20 +0,0 @@
-/**
- * Middleware para capturar el body de las solicitudes
- * Permite que el body esté disponible para los hooks
- */
-
-const express = require('express');
-
-// Middleware para capturar el body
-const captureBodyMiddleware = express.json({ 
-  verify: (req, res, buf, encoding) => {
-    req.rawBody = buf;
-    try {
-      req.capturedBody = JSON.parse(buf.toString(encoding));
-    } catch (e) {
-      req.capturedBody = buf.toString(encoding);
-    }
-  }
-});
-
-module.exports = { captureBodyMiddleware };