expressed-example-app 2.0.0 → 2.1.0

package/README.md

@@ -1,22 +1,26 @@
 # 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.
+This is a sample Express.js application demonstrating the usage of the `express-router-bds` routing system with custom hooks, advanced features, and integrated queue system.
 
 ## Overview
 
 This example application showcases:
 
-- High-performance routing with `express-router-bDS`
+- High-performance routing with `express-router-bds`
 - JSON-based route configuration
 - Custom hook system implementation
 - Parameterized route handling
 - Directory-based route loading
+- Integrated queue system with `express-queued`
+- Declarative route definitions in separate JSON files
 
 ## 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`
+- **Integrated Queue System**: Background task processing with `express-queued`
+- **Declarative Routes**: Separate route files for different functionalities
 - **Extensible Architecture**: Easy to extend with custom middleware and hooks
 
 ## Project Structure
@@ -24,26 +28,54 @@ This example application showcases:
 ```
 express-app/
 ├── app.js                 # Main application entry point
+├── queue-system.js        # Queue system integration
 ├── hooks-config.js        # Base hook configurations
 ├── hooks-personalizados.js # Custom hook implementations
 ├── controllers/
-│   ├── mainController.js  # Home and init route handlers
+│   ├── mainController.js  # Home, init and queue route handlers
 │   ├── productController.js # Product route handlers
 │   └── userController.js  # User route handlers
 ├── routes/
-│   └── main-routes.json   # Route definitions in JSON format
+│   ├── main-routes.json   # Main route definitions in JSON format
+│   └── queue-routes.json  # Queue-related route definitions
 └── node_modules/
-    └── express-router-bds/ # Custom routing system
+    ├── express-router-bds/ # Custom routing system
+    └── express-queued/    # Queue system
 ```
 
 ## Available Endpoints
 
+### Main 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
 
+### Queue System Endpoints
+- `GET /queue-status` - Get the status of the queue system
+- `GET /start-queues` - Start the queue system
+- `GET /stop-queues` - Stop the queue system
+- `POST /process-user` - Add a user processing task to the queue
+- `POST /process-product` - Add a product processing task to the queue
+- `POST /send-email` - Add an email sending task to the queue
+
+## Queue System
+
+The application integrates `express-queued` for background task processing:
+
+- **Multiple Queues**: Dedicated queues for different types of tasks
+- **Configurable Concurrency**: Control how many tasks execute simultaneously per queue
+- **Retry System**: Automatic failure handling with configurable retries
+- **Priority Management**: Assign priorities to tasks
+- **Hooks Integration**: Customize processing with hooks
+
+### Queue Types
+- `procesamiento-general` - General processing tasks
+- `envio-correos` - Email sending tasks
+- `procesamiento-usuarios` - User processing tasks
+- `procesamiento-productos` - Product processing tasks
+
 ## Hook System
 
 The application demonstrates several types of hooks:
@@ -74,7 +106,7 @@ The application will be available at `http://localhost:3000`
 
 ## Testing
 
-Test the endpoints:
+Test the main endpoints:
 
 ```bash
 curl http://localhost:3000
@@ -82,6 +114,23 @@ curl http://localhost:3000/users/123
 curl http://localhost:3000/products/electronics/456
 ```
 
+Test the queue system:
+
+```bash
+# Check queue status
+curl http://localhost:3000/queue-status
+
+# Add a user processing task
+curl -X POST http://localhost:3000/process-user \
+  -H "Content-Type: application/json" \
+  -d '{"userId": "123", "name": "John Doe", "email": "john@example.com"}'
+
+# Add an email sending task
+curl -X POST http://localhost:3000/send-email \
+  -H "Content-Type: application/json" \
+  -d '{"to": "test@example.com", "subject": "Test", "content": "Test content"}'
+```
+
 ## License
 
 This project is part of the `express-router-bds` ecosystem and follows the same licensing terms.

package/app.js

@@ -3,6 +3,7 @@ const ExpressRouterIntegration = require('express-router-bds');
 const RouteDirectoryLoader = require('express-router-bds/RouteDirectoryLoader');
 const AppHooks = require('./hooks-config');
 const HooksPersonalizados = require('./hooks-personalizados');
+const QueueSystem = require('./queue-system');
 
 const app = express();
 const PORT = process.env.PORT || 3000;
@@ -10,16 +11,29 @@ const PORT = process.env.PORT || 3000;
 // Crear instancia del router
 const routerIntegration = new ExpressRouterIntegration();
 
+// Crear instancia del sistema de colas
+const queueSystem = new QueueSystem();
+
 // Inicializar hooks y filtros
 const appHooks = new AppHooks(app, routerIntegration.getHooks());
 
 // Inicializar hooks personalizados
 const hooksPersonalizados = new HooksPersonalizados(routerIntegration);
 
-
 // Cargar rutas desde directorio
 const routeDirectoryLoader = new RouteDirectoryLoader();
 
+// Middleware para parsear JSON
+app.use(express.json());
+
+// Middleware para inyectar el sistema de colas en las solicitudes
+app.use(queueSystem.getInstance().queueMiddleware());
+
+// Middleware para inyectar el sistema de rutas en las solicitudes
+app.use((req, res, next) => {
+  req.routerIntegration = routerIntegration;
+  next();
+});
 
 routerIntegration.addHook('route_matched', (matchedRoute, req, res) => {
   console.log(`Ruta encontrada: ${matchedRoute.route.path}`);
@@ -41,6 +55,20 @@ routeDirectoryLoader.loadRoutesFromDirectory(routerIntegration, './routes')
     console.error('Error cargando rutas desde directorio:', error.message);
   });
 
+// Cargar rutas específicas de colas
+const RouteLoader = require('express-router-bds/RouteLoader');
+const queueRouteLoader = new RouteLoader();
+queueRouteLoader.loadRoutes(routerIntegration, './routes/queue-routes.json')
+  .then(queueRoutes => {
+    console.log(`${queueRoutes.length} rutas de colas cargadas`);
+    queueRoutes.forEach(route => {
+      console.log(`Ruta de cola cargada: ${route.method} ${route.path}`);
+    });
+  })
+  .catch(error => {
+    console.error('Error cargando rutas de colas:', error.message);
+  });
+
 // Aplicar el router a la aplicación Express
 routerIntegration.applyToApp(app);
 
@@ -49,6 +77,72 @@ app.use((req, res) => {
   res.status(404).json({ error: 'Ruta no encontrada' });
 });
 
+// Ruta para obtener el estado del sistema de colas
+app.get('/queue-status', (req, res) => {
+  const status = req.getQueueStatus();
+  res.json(status);
+});
+
+// Ruta para iniciar el sistema de colas
+app.get('/start-queues', (req, res) => {
+  queueSystem.start();
+  res.json({ message: 'Sistema de colas iniciado' });
+});
+
+// Ruta para detener el sistema de colas
+app.get('/stop-queues', (req, res) => {
+  queueSystem.stop();
+  res.json({ message: 'Sistema de colas detenido' });
+});
+
+// Ruta para procesar un usuario en cola
+app.post('/process-user', (req, res) => {
+  const { userId, name, email } = req.body;
+  
+  if (!userId) {
+    return res.status(400).json({ error: 'userId es requerido' });
+  }
+  
+  const taskId = queueSystem.addUserProcessingTask({ userId, name, email });
+  
+  res.json({
+    message: 'Tarea de procesamiento de usuario agregada a la cola',
+    taskId
+  });
+});
+
+// Ruta para procesar un producto en cola
+app.post('/process-product', (req, res) => {
+  const { productId, name, price } = req.body;
+  
+  if (!productId) {
+    return res.status(400).json({ error: 'productId es requerido' });
+  }
+  
+  const taskId = queueSystem.addProductProcessingTask({ productId, name, price });
+  
+  res.json({
+    message: 'Tarea de procesamiento de producto agregada a la cola',
+    taskId
+  });
+});
+
+// Ruta para enviar un correo en cola
+app.post('/send-email', (req, res) => {
+  const { to, subject, content } = req.body;
+  
+  if (!to) {
+    return res.status(400).json({ error: 'to es requerido' });
+  }
+  
+  const taskId = queueSystem.addEmailSendingTask({ to, subject, content });
+  
+  res.json({
+    message: 'Tarea de envío de correo agregada a la cola',
+    taskId
+  });
+});
+
 // Iniciar el servidor
 app.listen(PORT, () => {
   console.log(`Servidor corriendo en el puerto ${PORT}`);
@@ -57,6 +151,17 @@ app.listen(PORT, () => {
   console.log('- GET /init');
   console.log('- GET /users/:id');
   console.log('- GET /products/:category/:id');
+  console.log('- GET /test-hook');
+  console.log('- GET /queue-status');
+  console.log('- GET /start-queues');
+  console.log('- GET /stop-queues');
+  console.log('- POST /process-user');
+  console.log('- POST /process-product');
+  console.log('- POST /send-email');
+  
+  // Iniciar el sistema de colas
+  queueSystem.start();
+  console.log('Sistema de colas iniciado');
 });
 
 module.exports = app;

package/controllers/mainController.js

@@ -24,11 +24,73 @@ class MainController {
    * @param {Object} res - Objeto de respuesta
    */
   init(req, res) {
-    res.json({ 
+    res.json({
       message: 'Aplicación inicializada correctamente con Router-BDS',
       status: 'success'
     });
   }
+
+  /**
+   * Obtiene el estado del sistema de colas
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  getQueueStatus(req, res) {
+    const status = req.getQueueStatus();
+    res.json(status);
+  }
+
+  /**
+   * Inicia el sistema de colas
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  startQueues(req, res) {
+    req.queueSystem.start();
+    res.json({ message: 'Sistema de colas iniciado' });
+  }
+
+  /**
+   * Detiene el sistema de colas
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  stopQueues(req, res) {
+    req.queueSystem.stop();
+    res.json({ message: 'Sistema de colas detenido' });
+  }
+
+  /**
+   * Agrega una tarea de envío de correo a la cola
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  sendEmailInQueue(req, res) {
+    const { to, subject, content } = req.body;
+
+    if (!to) {
+      return res.status(400).json({ error: 'to es requerido' });
+    }
+
+    const taskId = req.addTask('envio-correos', async (data, taskObj) => {
+      console.log(`[ENVIO-CORREO] Enviando correo a: ${data.to}`);
+      
+      // Simular envío de correo (con 10% de probabilidad de fallo)
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      
+      if (Math.random() < 0.1) {
+        throw new Error(`Fallo al enviar correo a: ${data.to}`);
+      }
+      
+      console.log(`[ENVIO-CORREO] Correo enviado exitosamente a: ${data.to}`);
+      return `Correo enviado a ${data.to} exitosamente`;
+    }, { to, subject, content });
+
+    res.json({
+      message: 'Tarea de envío de correo agregada a la cola',
+      taskId
+    });
+  }
 }
 
 module.exports = new MainController();

package/controllers/productController.js

@@ -10,13 +10,41 @@ class ProductController {
   getProduct(req, res) {
     const category = req.params.category;
     const productId = req.params.id;
-    res.json({ 
+    res.json({
       message: `Obteniendo producto de la categoría "${category}" con ID: ${productId}`,
       category: category,
       productId: productId,
       timestamp: new Date().toISOString()
     });
   }
+
+  /**
+   * Procesa un producto en cola
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  processProductInQueue(req, res) {
+    const { productId, name, price } = req.body;
+
+    if (!productId) {
+      return res.status(400).json({ error: 'productId es requerido' });
+    }
+
+    const taskId = req.addTask('procesamiento-productos', async (data, taskObj) => {
+      console.log(`[PROCESAMIENTO-PRODUCTO] Procesando producto:`, data.productId || data.id);
+      
+      // Simular procesamiento
+      await new Promise(resolve => setTimeout(resolve, 1500));
+      
+      console.log(`[PROCESAMIENTO-PRODUCTO] Producto procesado exitosamente:`, data.productId || data.id);
+      return `Producto ${data.productId || data.id} procesado exitosamente`;
+    }, { productId, name, price });
+
+    res.json({
+      message: 'Tarea de procesamiento de producto agregada a la cola',
+      taskId
+    });
+  }
 }
 
 module.exports = new ProductController();

package/controllers/userController.js

@@ -9,12 +9,40 @@ class UserController {
    */
   getUser(req, res) {
     const userId = req.params.id;
-    res.json({ 
+    res.json({
       message: `Obteniendo información del usuario con ID: ${userId}`,
       userId: userId,
       timestamp: new Date().toISOString()
     });
   }
+
+  /**
+   * Procesa un usuario en cola
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  processUserInQueue(req, res) {
+    const { userId, name, email } = req.body;
+
+    if (!userId) {
+      return res.status(400).json({ error: 'userId es requerido' });
+    }
+
+    const taskId = req.addTask('procesamiento-usuarios', async (data, taskObj) => {
+      console.log(`[PROCESAMIENTO-USUARIO] Procesando usuario:`, data.userId || data.id);
+      
+      // Simular procesamiento
+      await new Promise(resolve => setTimeout(resolve, 2000));
+      
+      console.log(`[PROCESAMIENTO-USUARIO] Usuario procesado exitosamente:`, data.userId || data.id);
+      return `Usuario ${data.userId || data.id} procesado exitosamente`;
+    }, { userId, name, email });
+
+    res.json({
+      message: 'Tarea de procesamiento de usuario agregada a la cola',
+      taskId
+    });
+  }
 }
 
 module.exports = new UserController();

package/package.json

@@ -1,13 +1,38 @@
 {
   "name": "expressed-example-app",
-  "version": "2.0.0",
-  "description": "",
+  "version": "2.1.0",
+  "description": "Advanced Express.js application featuring high-performance routing with custom hooks, declarative route definitions, and integrated queue system for background task processing. Perfect for scalable web applications requiring sophisticated routing and async job handling.",
   "main": "app.js",
   "scripts": {
     "start": "node app.js",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": ["web express example"],
+  "keywords": [
+    "express",
+    "routing",
+    "router",
+    "middleware",
+    "api",
+    "rest",
+    "web-framework",
+    "backend",
+    "server",
+    "http",
+    "framework",
+    "nodejs",
+    "javascript",
+    "queues",
+    "async",
+    "asynchronous",
+    "tasks",
+    "jobs",
+    "background-jobs",
+    "hooks",
+    "extensible",
+    "modular",
+    "declarative-routing",
+    "web express example"
+  ],
   "author": "BDS",
   "license": "ISC",
   "dependencies": {

package/queue-system.js

@@ -0,0 +1,128 @@
+// queue-system.js
+// Sistema de colas para la aplicación Express
+
+const ExpressQueueIntegration = require('express-queued');
+
+class QueueSystem {
+  constructor() {
+    // Crear instancia del sistema de colas
+    this.expressQueue = new ExpressQueueIntegration();
+    
+    // Configurar las colas
+    this.setupQueues();
+  }
+
+  setupQueues() {
+    // Cola para procesamiento general
+    this.expressQueue.createQueue('procesamiento-general', {
+      concurrency: 2,
+      retryAttempts: 3,
+      retryDelay: 1000
+    });
+
+    // Cola para envío de correos
+    this.expressQueue.createQueue('envio-correos', {
+      concurrency: 1,
+      retryAttempts: 5,
+      retryDelay: 2000
+    });
+
+    // Cola para procesamiento de usuarios
+    this.expressQueue.createQueue('procesamiento-usuarios', {
+      concurrency: 3,
+      retryAttempts: 2,
+      retryDelay: 1500
+    });
+
+    // Cola para procesamiento de productos
+    this.expressQueue.createQueue('procesamiento-productos', {
+      concurrency: 2,
+      retryAttempts: 3,
+      retryDelay: 1000
+    });
+  }
+
+  // Método para obtener la instancia del sistema de colas
+  getInstance() {
+    return this.expressQueue;
+  }
+
+  // Método para iniciar el sistema de colas
+  start() {
+    this.expressQueue.start();
+  }
+
+  // Método para detener el sistema de colas
+  stop() {
+    this.expressQueue.stop();
+  }
+
+  // Ejemplo de tarea para procesamiento de usuarios
+  addUserProcessingTask(userData) {
+    return this.expressQueue.addTask(
+      'procesamiento-usuarios',
+      this.processUser.bind(this),
+      userData,
+      0 // Prioridad alta
+    );
+  }
+
+  // Ejemplo de tarea para procesamiento de productos
+  addProductProcessingTask(productData) {
+    return this.expressQueue.addTask(
+      'procesamiento-productos',
+      this.processProduct.bind(this),
+      productData,
+      0 // Prioridad alta
+    );
+  }
+
+  // Ejemplo de tarea para envío de correos
+  addEmailSendingTask(emailData) {
+    return this.expressQueue.addTask(
+      'envio-correos',
+      this.sendEmail.bind(this),
+      emailData,
+      0 // Prioridad alta
+    );
+  }
+
+  // Función de ejemplo para procesamiento de usuarios
+  async processUser(data, taskObj) {
+    console.log(`[PROCESAMIENTO-USUARIO] Procesando usuario:`, data.userId || data.id);
+    
+    // Simular procesamiento
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    console.log(`[PROCESAMIENTO-USUARIO] Usuario procesado exitosamente:`, data.userId || data.id);
+    return `Usuario ${data.userId || data.id} procesado exitosamente`;
+  }
+
+  // Función de ejemplo para procesamiento de productos
+  async processProduct(data, taskObj) {
+    console.log(`[PROCESAMIENTO-PRODUCTO] Procesando producto:`, data.productId || data.id);
+    
+    // Simular procesamiento
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    
+    console.log(`[PROCESAMIENTO-PRODUCTO] Producto procesado exitosamente:`, data.productId || data.id);
+    return `Producto ${data.productId || data.id} procesado exitosamente`;
+  }
+
+  // Función de ejemplo para envío de correos
+  async sendEmail(data, taskObj) {
+    console.log(`[ENVIO-CORREO] Enviando correo a:`, data.email || data.to);
+    
+    // Simular envío de correo (con 10% de probabilidad de fallo)
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    if (Math.random() < 0.1) {
+      throw new Error(`Fallo al enviar correo a: ${data.email || data.to}`);
+    }
+    
+    console.log(`[ENVIO-CORREO] Correo enviado exitosamente a:`, data.email || data.to);
+    return `Correo enviado a ${data.email || data.to} exitosamente`;
+  }
+}
+
+module.exports = QueueSystem;

package/routes/queue-routes.json

@@ -0,0 +1,44 @@
+[
+  {
+    "method": "GET",
+    "path": "/queue-status",
+    "controller": "./controllers/mainController",
+    "handler": "getQueueStatus",
+    "contentType": "application/json"
+  },
+  {
+    "method": "GET",
+    "path": "/start-queues",
+    "controller": "./controllers/mainController",
+    "handler": "startQueues",
+    "contentType": "application/json"
+  },
+  {
+    "method": "GET",
+    "path": "/stop-queues",
+    "controller": "./controllers/mainController",
+    "handler": "stopQueues",
+    "contentType": "application/json"
+  },
+  {
+    "method": "POST",
+    "path": "/process-user",
+    "controller": "./controllers/userController",
+    "handler": "processUserInQueue",
+    "contentType": "application/json"
+  },
+  {
+    "method": "POST",
+    "path": "/process-product",
+    "controller": "./controllers/productController",
+    "handler": "processProductInQueue",
+    "contentType": "application/json"
+  },
+  {
+    "method": "POST",
+    "path": "/send-email",
+    "controller": "./controllers/mainController",
+    "handler": "sendEmailInQueue",
+    "contentType": "application/json"
+  }
+]