expressed-core 1.0.0

package/queued/express-example.js

@@ -0,0 +1,143 @@
+/**
+ * Ejemplo de uso del sistema de colas con Express
+ * Archivo de ejemplo: express-example.js
+ */
+
+const express = require('express');
+const ExpressQueueIntegration = require('./express-integration');
+
+// Crear una aplicación Express
+const app = express();
+const port = 3032;
+
+// Middleware para parsear JSON en el body
+app.use(express.json());
+
+// Crear instancia de la integración de colas para Express
+const expressQueue = new ExpressQueueIntegration();
+
+// Configurar una cola para procesamiento de imágenes
+expressQueue.createQueue('imagenes', {
+  concurrency: 3,
+  retryAttempts: 2,
+  retryDelay: 1000
+});
+
+// Configurar una cola para envío de correos
+expressQueue.createQueue('correos', {
+  concurrency: 2,
+  retryAttempts: 3,
+  retryDelay: 2000
+});
+
+// Ejemplo de tarea para procesamiento de imágenes
+function procesarImagen(datos, taskObj) {
+  return new Promise(async (resolve, reject) => {
+    console.log(`[IMAGEN] Procesando imagen: ${datos.nombreArchivo}`);
+
+    try {
+      // Importar fs para escribir archivos
+      const fs = require('fs');
+      const path = require('path');
+
+      // Crear un contenido simple para la imagen (texto)
+      const imagePath = path.join(__dirname, datos.nombreArchivo);
+      const content = `Archivo de imagen: ${datos.nombreArchivo}\nTamaño: ${datos.tamano}\nFecha de procesamiento: ${new Date().toISOString()}\n\nEste archivo fue generado por el sistema de colas de Express.`;
+
+      // Escribir el contenido en el archivo
+      fs.writeFileSync(imagePath, content);
+
+      console.log(`[IMAGEN] Imagen procesada exitosamente: ${datos.nombreArchivo} (${datos.tamano})`);
+      resolve(`Imagen ${datos.nombreArchivo} procesada con éxito y guardada en ${imagePath}`);
+    } catch (error) {
+      console.error(`[IMAGEN] Falló el procesamiento de: ${datos.nombreArchivo}`, error);
+      reject(new Error(`Error procesando imagen: ${datos.nombreArchivo} - ${error.message}`));
+    }
+  });
+}
+
+// Ejemplo de tarea para envío de correos
+function enviarCorreo(datos, taskObj) {
+  return new Promise((resolve, reject) => {
+    console.log(`[CORREO] Enviando correo a: ${datos.destinatario}`);
+
+    // Simular un proceso de envío de correo
+    setTimeout(() => {
+      if (Math.random() < 0.15) { // 15% de probabilidad de fallo
+        console.error(`[CORREO] Falló el envío a: ${datos.destinatario}`);
+        reject(new Error(`Error enviando correo a: ${datos.destinatario}`));
+      } else {
+        console.log(`[CORREO] Correo enviado exitosamente a: ${datos.destinatario}`);
+        resolve(`Correo enviado a ${datos.destinatario} con éxito`);
+      }
+    }, 1500);
+  });
+}
+
+// Middleware para inyectar el sistema de colas en las solicitudes
+app.use(expressQueue.queueMiddleware());
+
+// Ruta para agregar una tarea de procesamiento de imagen
+app.post('/procesar-imagen', (req, res) => {
+  const { nombreArchivo, tamano } = req.body;
+
+  const taskId = req.addTask('imagenes', procesarImagen, {
+    nombreArchivo,
+    tamano
+  });
+
+  res.json({ 
+    message: 'Tarea de procesamiento de imagen agregada a la cola',
+    taskId 
+  });
+});
+
+// Ruta para agregar una tarea de envío de correo
+app.post('/enviar-correo', (req, res) => {
+  const { destinatario, asunto, contenido } = req.body;
+
+  const taskId = req.addTask('correos', enviarCorreo, {
+    destinatario,
+    asunto,
+    contenido
+  });
+
+  res.json({ 
+    message: 'Tarea de envío de correo agregada a la cola',
+    taskId 
+  });
+});
+
+// Ruta para obtener el estado del sistema de colas
+app.get('/estado-colas', (req, res) => {
+  const status = req.getQueueStatus();
+  res.json(status);
+});
+
+// Ruta para iniciar el sistema de colas
+app.get('/iniciar-colas', (req, res) => {
+  req.queueSystem.start();
+  res.json({ message: 'Sistema de colas iniciado' });
+});
+
+// Ruta para detener el sistema de colas
+app.get('/detener-colas', (req, res) => {
+  req.queueSystem.stop();
+  res.json({ message: 'Sistema de colas detenido' });
+});
+
+// Iniciar el servidor
+app.listen(port, () => {
+  console.log(`Servidor Express escuchando en http://localhost:${port}`);
+  console.log('Sistema de colas para Express inicializado');
+  console.log('Endpoints disponibles:');
+  console.log('- POST /procesar-imagen');
+  console.log('- POST /enviar-correo');
+  console.log('- GET /estado-colas');
+  console.log('- GET /iniciar-colas');
+  console.log('- GET /detener-colas');
+});
+
+// Iniciar el sistema de colas
+expressQueue.start();
+console.log('Sistema de colas iniciado');

package/queued/express-integration.js

@@ -0,0 +1,115 @@
+/**
+ * Integración del Sistema de Colas para Express
+ * Archivo de integración para usar el sistema de colas con Express
+ */
+
+const QueueSystem = require('./QueueSystem');
+const HookSystem = require('../hooked/hooks'); // Usar el sistema de hooks de @expressed/hooked/
+
+class ExpressQueueIntegration {
+  /**
+   * Constructor de la integración
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    // Crear instancia del sistema de hooks
+    this.hooks = new HookSystem();
+    
+    // Crear instancia del sistema de colas con los hooks
+    this.queueSystem = new QueueSystem({...options, hooks: this.hooks});
+  }
+
+  /**
+   * Obtiene el sistema de colas
+   * @returns {QueueSystem} - Instancia del sistema de colas
+   */
+  getQueueSystem() {
+    return this.queueSystem;
+  }
+
+  /**
+   * Obtiene el sistema de hooks
+   * @returns {HookSystem} - Instancia del sistema de hooks
+   */
+  getHooks() {
+    return this.hooks;
+  }
+
+  /**
+   * Crea una cola específica con hooks personalizados
+   * @param {string} queueName - Nombre de la cola
+   * @param {Object} options - Opciones específicas para la cola
+   * @param {Object} hooks - Sistema de hooks específico para esta cola (opcional)
+   * @returns {Object} - Cola creada
+   */
+  createQueue(queueName, options = {}, hooks = null) {
+    // Si se proporcionan hooks específicos para esta cola, usarlos
+    if (hooks) {
+      options.hooks = hooks;
+    }
+
+    // Crear la cola con las opciones
+    return this.queueSystem.getOrCreateQueue(queueName, options);
+  }
+
+  /**
+   * Agrega una tarea a una cola
+   * @param {string} queueName - Nombre de la cola
+   * @param {Function} task - Función que representa la tarea
+   * @param {Object} data - Datos para la tarea
+   * @param {number} priority - Prioridad de la tarea
+   * @returns {string} - ID único de la tarea
+   */
+  addTask(queueName, task, data = {}, priority = 0) {
+    return this.queueSystem.addTask(queueName, task, data, priority);
+  }
+
+  /**
+   * Inicia la ejecución de tareas en todas las colas
+   */
+  start() {
+    this.queueSystem.start();
+  }
+
+  /**
+   * Detiene la ejecución de tareas en todas las colas
+   */
+  stop() {
+    this.queueSystem.stop();
+  }
+
+  /**
+   * Obtiene el estado actual del sistema de colas
+   * @returns {Object} - Estado del sistema de colas
+   */
+  getStatus() {
+    return this.queueSystem.getStatus();
+  }
+
+  /**
+   * Reintenta todas las tareas fallidas en una cola específica
+   * @param {string} queueName - Nombre de la cola
+   */
+  retryFailedTasks(queueName) {
+    this.queueSystem.retryFailedTasks(queueName);
+  }
+
+  /**
+   * Middleware para inyectar el sistema de colas en las solicitudes de Express
+   * @returns {Function} - Middleware de Express
+   */
+  queueMiddleware() {
+    return (req, res, next) => {
+      // Inyectar el sistema de colas y hooks en el objeto de solicitud
+      req.queueSystem = this.queueSystem;
+      req.queueHooks = this.hooks;
+      req.createQueue = this.createQueue.bind(this);
+      req.addTask = this.addTask.bind(this);
+      req.getQueueStatus = this.getStatus.bind(this);
+      
+      next();
+    };
+  }
+}
+
+module.exports = ExpressQueueIntegration;

package/queued/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "express-queued",
+  "version": "1.0.0",
+  "description": "Independent queue system for Express with support for hooks",
+  "main": "express-integration.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "express",
+    "queues",
+    "tasks",
+    "jobs",
+    "background-jobs",
+    "hooks"
+  ],
+  "author": "Benjamin Sanchez Cardenas",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "express-hooked": "^1.0.0"
+  },
+  "peerDependencies": {
+    "express": "^4.18.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/bytedogssyndicate1/express-queued.git"
+  },
+  "bugs": {
+    "url": "https://gitlab.com/bytedogssyndicate1/express-queued/issues"
+  },
+  "homepage": "https://gitlab.com/bytedogssyndicate1/express-queued#readme"
+}

package/router/ExpressRouter.js

@@ -0,0 +1,247 @@
+/**
+ * Sistema de enrutamiento para Express basado en la arquitectura de insitu-js
+ * Express-Router v1.0.0 - Sistema de enrutamiento optimizado para Express
+ */
+
+const RouteMatcher = require('./RouteMatcher');
+const HookSystem = require('express-hooked/hooks'); // Importar el sistema de hooks base
+
+class ExpressRouter {
+  /**
+   * Constructor del router de Express
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    this.routes = [];
+    this.hooks = new HookSystem(); // Crear instancia de HookSystem
+    this.routeMatcher = new RouteMatcher();
+    
+    // Establecer la referencia de hooks en el RouteMatcher
+    this.routeMatcher.hooks = this.hooks;
+    
+    // Opciones de configuración
+    this.options = {
+      caseSensitive: options.caseSensitive || false,
+      strict: options.strict || false,
+      mergeParams: options.mergeParams || false
+    };
+  }
+
+  /**
+   * Método para agregar una ruta GET
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouter} - Instancia del router para encadenamiento
+   */
+  get(path, handler) {
+    this.addRoute('GET', path, handler);
+    return this;
+  }
+
+  /**
+   * Método para agregar una ruta POST
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouter} - Instancia del router para encadenamiento
+   */
+  post(path, handler) {
+    this.addRoute('POST', path, handler);
+    return this;
+  }
+
+  /**
+   * Método para agregar una ruta PUT
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouter} - Instancia del router para encadenamiento
+   */
+  put(path, handler) {
+    this.addRoute('PUT', path, handler);
+    return this;
+  }
+
+  /**
+   * Método para agregar una ruta DELETE
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouter} - Instancia del router para encadenamiento
+   */
+  delete(path, handler) {
+    this.addRoute('DELETE', path, handler);
+    return this;
+  }
+
+  /**
+   * Método para agregar una ruta PATCH
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouter} - Instancia del router para encadenamiento
+   */
+  patch(path, handler) {
+    this.addRoute('PATCH', path, handler);
+    return this;
+  }
+
+  /**
+   * Método para agregar una ruta genérica
+   * @param {string} method - Método HTTP
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouter} - Instancia del router para encadenamiento
+   */
+  addRoute(method, path, handler) {
+    // Disparar hook antes de agregar la ruta
+    this.hooks.doAction('before_add_route', { method, path, handler });
+
+    // Verificar si ya existe una ruta con el mismo método y path
+    const existingRouteIndex = this.routes.findIndex(
+      route => route.method === method.toUpperCase() && route.path === path
+    );
+
+    if (existingRouteIndex !== -1) {
+      // Si ya existe, reemplazarla
+      this.routes[existingRouteIndex] = {
+        method: method.toUpperCase(),
+        path,
+        handler,
+        isStatic: !path.includes(':') // Determinar si es ruta estática
+      };
+    } else {
+      // Si no existe, agregarla
+      this.routes.push({
+        method: method.toUpperCase(),
+        path,
+        handler,
+        isStatic: !path.includes(':') // Determinar si es ruta estática
+      });
+    }
+
+    // Disparar hook después de agregar la ruta
+    this.hooks.doAction('route_added', {
+      method: method.toUpperCase(),
+      path,
+      handler
+    });
+
+    return this;
+  }
+
+  /**
+   * Método para agregar múltiples rutas de una sola vez
+   * @param {Array} routes - Array de rutas con formato {method, path, handler}
+   * @returns {ExpressRouter} - Instancia del router para encadenamiento
+   */
+  addRoutes(routes) {
+    for (const route of routes) {
+      this.addRoute(route.method, route.path, route.handler);
+    }
+    return this;
+  }
+
+  /**
+   * Método para obtener todas las rutas
+   * @returns {Array} - Array con todas las rutas registradas
+   */
+  getRoutes() {
+    return this.routes;
+  }
+
+  /**
+   * Middleware principal del router
+   * @returns {Function} - Middleware de Express
+   */
+  middleware() {
+    return (req, res, next) => {
+      // Disparar hook antes de procesar la ruta
+      this.hooks.doAction('before_route_processing', req, res);
+
+      // Encontrar la ruta coincidente
+      const matchedRoute = this.routeMatcher.findRoute(
+        this.routes,
+        req.method,
+        req.url.split('?')[0] // Quitar query string para la coincidencia
+      );
+
+      if (matchedRoute) {
+        // Disparar hook cuando se encuentra una ruta coincidente
+        this.hooks.doAction('route_matched', matchedRoute, req, res);
+
+        // Agregar parámetros a la solicitud
+        if (matchedRoute.params) {
+          req.params = { ...req.params, ...matchedRoute.params };
+        }
+
+        // Ejecutar el handler de la ruta
+        try {
+          // Disparar hook antes de ejecutar el handler
+          this.hooks.doAction('before_route_handler', req, res, next);
+
+          // Ejecutar el handler con los parámetros adecuados
+          matchedRoute.route.handler(req, res, next);
+
+          // Disparar hook después de ejecutar el handler
+          this.hooks.doAction('after_route_handler', req, res);
+        } catch (error) {
+          // Disparar hook si ocurre un error en el handler
+          this.hooks.doAction('route_handler_error', error, req, res, next);
+          
+          // Pasar el error al siguiente middleware
+          next(error);
+        }
+      } else {
+        // Si no se encuentra una ruta coincidente, pasar al siguiente middleware
+        next();
+      }
+    };
+  }
+
+  /**
+   * Método para aplicar el router a una aplicación Express
+   * @param {Object} app - Aplicación Express
+   */
+  applyToApp(app) {
+    app.use(this.middleware());
+  }
+
+  /**
+   * Método para obtener el sistema de hooks
+   * @returns {HookSystem} - Instancia del sistema de hooks
+   */
+  getHooks() {
+    return this.hooks;
+  }
+
+  /**
+   * Método para registrar un hook personalizado
+   * @param {string} hookName - Nombre del hook
+   * @param {Function} callback - Función de callback
+   * @param {number} priority - Prioridad del callback
+   * @param {number} acceptedArgs - Número de argumentos aceptados
+   * @param {string} identifier - Identificador opcional
+   */
+  addHook(hookName, callback, priority = 10, acceptedArgs = 1, identifier = null) {
+    this.hooks.addAction(hookName, callback, priority, acceptedArgs, identifier);
+  }
+
+  /**
+   * Método para disparar un hook
+   * @param {string} hookName - Nombre del hook
+   * @param {...any} args - Argumentos para el hook
+   */
+  doHook(hookName, ...args) {
+    this.hooks.doAction(hookName, ...args);
+  }
+
+  /**
+   * Método para aplicar un filtro
+   * @param {string} hookName - Nombre del filtro
+   * @param {any} value - Valor a filtrar
+   * @param {...any} additionalArgs - Argumentos adicionales
+   * @returns {any} - Valor filtrado
+   */
+  applyFilter(hookName, value, ...additionalArgs) {
+    return this.hooks.applyFilters(hookName, value, ...additionalArgs);
+  }
+}
+
+module.exports = ExpressRouter;

package/router/ExpressRouterIntegration.js

@@ -0,0 +1,129 @@
+/**
+ * Integración del sistema de enrutamiento para Express
+ * Express-Router v1.0.0 - Integración con Express
+ */
+
+const ExpressRouter = require('./ExpressRouter');
+
+class ExpressRouterIntegration {
+  /**
+   * Constructor de la integración
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    this.router = new ExpressRouter(options);
+  }
+
+  /**
+   * Método para obtener el router
+   * @returns {ExpressRouter} - Instancia del router
+   */
+  getRouter() {
+    return this.router;
+  }
+
+  /**
+   * Método para agregar una ruta GET
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouterIntegration} - Instancia de la integración para encadenamiento
+   */
+  get(path, handler) {
+    this.router.get(path, handler);
+    return this;
+  }
+
+  /**
+   * Método para agregar una ruta POST
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouterIntegration} - Instancia de la integración para encadenamiento
+   */
+  post(path, handler) {
+    this.router.post(path, handler);
+    return this;
+  }
+
+  /**
+   * Método para agregar una ruta PUT
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouterIntegration} - Instancia de la integración para encadenamiento
+   */
+  put(path, handler) {
+    this.router.put(path, handler);
+    return this;
+  }
+
+  /**
+   * Método para agregar una ruta DELETE
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouterIntegration} - Instancia de la integración para encadenamiento
+   */
+  delete(path, handler) {
+    this.router.delete(path, handler);
+    return this;
+  }
+
+  /**
+   * Método para agregar una ruta PATCH
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouterIntegration} - Instancia de la integración para encadenamiento
+   */
+  patch(path, handler) {
+    this.router.patch(path, handler);
+    return this;
+  }
+
+  /**
+   * Método para agregar una ruta genérica
+   * @param {string} method - Método HTTP
+   * @param {string} path - Ruta del endpoint
+   * @param {Function} handler - Función manejadora de la ruta
+   * @returns {ExpressRouterIntegration} - Instancia de la integración para encadenamiento
+   */
+  addRoute(method, path, handler) {
+    this.router.addRoute(method, path, handler);
+    return this;
+  }
+
+  /**
+   * Método para aplicar el router a una aplicación Express
+   * @param {Object} app - Aplicación Express
+   */
+  applyToApp(app) {
+    this.router.applyToApp(app);
+  }
+
+  /**
+   * Middleware para usar con Express
+   * @returns {Function} - Middleware de Express
+   */
+  middleware() {
+    return this.router.middleware();
+  }
+
+  /**
+   * Método para obtener el sistema de hooks
+   * @returns {HookSystem} - Instancia del sistema de hooks
+   */
+  getHooks() {
+    return this.router.getHooks();
+  }
+
+  /**
+   * Método para registrar un hook personalizado
+   * @param {string} hookName - Nombre del hook
+   * @param {Function} callback - Función de callback
+   * @param {number} priority - Prioridad del callback
+   * @param {number} acceptedArgs - Número de argumentos aceptados
+   * @param {string} identifier - Identificador opcional
+   */
+  addHook(hookName, callback, priority = 10, acceptedArgs = 1, identifier = null) {
+    this.router.addHook(hookName, callback, priority, acceptedArgs, identifier);
+  }
+}
+
+module.exports = ExpressRouterIntegration;