expressed-example-app 1.0.0

package/app.js

@@ -0,0 +1,115 @@
+/**
+ * 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');
+
+// 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'));
+
+// Inicializar el sistema de hooks
+const hooked = new ExpressHooked(app);
+
+// Inicializar el sistema de enrutamiento
+const router = new ExpressRouterIntegration();
+
+// Inicializar el sistema de colas
+const queueSystem = new ExpressQueueIntegration();
+
+// Registrar los hooks de la aplicación
+AppHooks.registerHooks(hooked);
+
+// Middleware para capturar el body
+app.use(captureBodyMiddleware);
+
+// 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`);
+  }
+}
+
+// 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();
+
+// Iniciar el sistema de hooks
+hooked.init();
+
+// 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
+  });
+});
+
+// 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}`);
+  });
+});

package/config/routes.json

@@ -0,0 +1,70 @@
+{
+  "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

@@ -0,0 +1,43 @@
+/**
+ * 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

@@ -0,0 +1,19 @@
+/**
+ * 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

@@ -0,0 +1,47 @@
+/**
+ * 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

@@ -0,0 +1,26 @@
+/**
+ * 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

@@ -0,0 +1,73 @@
+/**
+ * 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

@@ -0,0 +1,60 @@
+/**
+ * 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

@@ -0,0 +1,20 @@
+/**
+ * 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 };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "expressed-example-app",
+  "version": "1.0.0",
+  "description": "Example application integrating @hooked, @router and @queued",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "nodemon app.js"
+  },
+  "dependencies": {
+    "express": "^4.22.1",
+    "express-hooked": "^1.0.1",
+    "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"
+}