expressed-core 1.0.0

package/router/node_modules/express-hooked/README.md

@@ -0,0 +1,123 @@
+# Express-Hooked
+
+Express-Hooked is a powerful extension for Express.js that brings a comprehensive hooks and filters system to your applications. Inspired by WordPress hooks system, it allows developers to extend functionality at various points in the request lifecycle without modifying core code.
+
+## Why Choose Express-Hooked?
+
+- **Flexible Architecture**: Hook into request processing at multiple stages
+- **Non-Intrusive**: Extend functionality without modifying existing code
+- **Priority System**: Control execution order with priority levels
+- **Namespace Support**: Organize hooks with namespaces for better maintainability
+- **Easy Integration**: Simple setup with minimal configuration
+
+## Installation
+
+```bash
+npm install express-hooked
+```
+
+## Quick Start
+
+```javascript
+const express = require('express');
+const ExpressHooked = require('express-hooked');
+
+const app = express();
+const port = 3000;
+
+// Initialize ExpressHooked
+const expressHooks = new ExpressHooked(app);
+
+// Register an action hook
+expressHooks.addAction('request_started', (req, res, next) => {
+  console.log(`Request received: ${req.method} ${req.url}`);
+  next();
+});
+
+// Register a filter hook
+expressHooks.addFilter('modify_response_data', (data) => {
+  return {
+    ...data,
+    processedBy: 'ExpressHooked',
+    timestamp: new Date().toISOString()
+  };
+});
+
+// Example route using filters
+app.get('/', (req, res) => {
+  let responseData = { message: 'Hello World!' };
+  responseData = expressHooks.applyFilters('modify_response_data', responseData);
+  
+  res.json(responseData);
+});
+
+// Initialize hooks integration
+expressHooks.init();
+
+app.listen(port, () => {
+  console.log(`Server running at http://localhost:${port}`);
+});
+```
+
+## Key Features
+
+### Actions
+Actions allow you to execute code at specific points without modifying data:
+
+```javascript
+expressHooks.addAction('request_started', (req, res, next) => {
+  // Do something when request starts
+  next();
+});
+```
+
+### Filters
+Filters allow you to modify data flowing through your application:
+
+```javascript
+expressHooks.addFilter('modify_response_data', (data) => {
+  // Modify and return the data
+  return { ...data, customField: 'value' };
+});
+```
+
+### Priority System
+Control execution order with priority levels (lower numbers execute first):
+
+```javascript
+// This executes first (higher priority)
+expressHooks.addAction('request_started', callback, 5);
+
+// This executes later (lower priority)  
+expressHooks.addAction('request_started', callback, 15);
+```
+
+### Namespaces
+Organize your hooks with namespaces:
+
+```javascript
+// Register hook with namespace
+expressHooks.addAction('myplugin::before_request', callback);
+
+// Execute namespaced hook
+expressHooks.doAction('myplugin::before_request', req, res);
+```
+
+## Use Cases
+
+- **Authentication & Authorization**: Hook into request processing to validate credentials
+- **Logging & Analytics**: Track requests, responses, and performance metrics
+- **Caching**: Implement caching strategies at different levels
+- **API Transformation**: Modify API responses before sending to clients
+- **Error Handling**: Centralized error handling with custom logic
+- **Rate Limiting**: Implement rate limiting based on custom criteria
+
+## Contributing
+
+We welcome contributions! Please see our contributing guidelines for more information.
+
+## License
+
+Apache 2.0
+
+Repository: https://gitlab.com/bytedogssyndicate1/express-hooked

package/router/node_modules/express-hooked/express-hooked.js

@@ -0,0 +1,206 @@
+/**
+ * Sistema de Hooks para Express
+ * Basado en el sistema de hooks independiente
+ * 
+ * @author Benjamin Sanchez Cardenas
+ * @license Apache 2.0
+ */
+
+// Importar el sistema de hooks independiente
+const HookSystem = require('./hooks');
+
+class ExpressHooked extends HookSystem {
+  constructor(app) {
+    super();
+    
+    // Almacenar la aplicación Express
+    this.app = app;
+    
+    // Registrar hooks predeterminados para eventos de Express
+    this._registerDefaultHooks();
+    
+    // Añadir el sistema de hooks a la aplicación Express
+    if (this.app) {
+      this.app.locals.hooks = this;
+    }
+  }
+
+  /**
+   * Registra hooks predeterminados para eventos de Express
+   * @private
+   */
+  _registerDefaultHooks() {
+    // Hooks para eventos de solicitud
+    this.addAction('request_started', (req, res, next) => {
+      // Este hook se ejecuta al inicio de cada solicitud
+      req.startTime = Date.now();
+      req.hookData = {}; // Objeto para almacenar datos entre hooks
+      next();
+    }, 5); // Alta prioridad para inicialización temprana
+    
+    this.addAction('request_processed', (req, res) => {
+      // Este hook se ejecuta después de procesar la solicitud
+      if (req.startTime) {
+        const duration = Date.now() - req.startTime;
+        req.duration = duration;
+        console.log(`Request ${req.method} ${req.url} took ${duration}ms`);
+      }
+    }, 15); // Baja prioridad para ejecución tardía
+    
+    this.addAction('response_sent', (req, res) => {
+      // Este hook se ejecuta después de enviar la respuesta
+      console.log(`Response sent for ${req.method} ${req.url}. Status: ${res.statusCode}`);
+    });
+  }
+
+  /**
+   * Middleware para disparar hooks al inicio de la solicitud
+   * @returns {Function} Middleware de Express
+   */
+  requestStartedMiddleware() {
+    return (req, res, next) => {
+      // Disparar hook al inicio de la solicitud
+      this.doAction('request_started', req, res, next);
+    };
+  }
+
+  /**
+   * Middleware para disparar hooks al finalizar la solicitud
+   * @returns {Function} Middleware de Express
+   */
+  requestProcessedMiddleware() {
+    return (req, res, next) => {
+      // Guardar la función original de res.end
+      const originalEnd = res.end;
+      
+      // Sobrescribir res.end para capturar cuando se envía la respuesta
+      res.end = function(chunk, encoding, callback) {
+        // Disparar hook antes de enviar la respuesta
+        this.doAction('request_processed', req, res);
+        
+        // Llamar a la función original
+        const result = originalEnd.call(res, chunk, encoding, callback);
+        
+        // Disparar hook después de enviar la respuesta
+        setImmediate(() => {
+          this.doAction('response_sent', req, res);
+        });
+        
+        return result;
+      }.bind(this);
+      
+      next();
+    };
+  }
+
+  /**
+   * Middleware para manejar errores y disparar hooks correspondientes
+   * @returns {Function} Middleware de Express
+   */
+  errorHandlerMiddleware() {
+    return (err, req, res, next) => {
+      // Disparar hook cuando ocurre un error
+      this.doAction('error_occurred', err, req, res, next);
+      
+      // Continuar con el manejo de errores de Express
+      next(err);
+    };
+  }
+
+  /**
+   * Middleware para disparar hooks antes de procesar la ruta
+   * @param {string} route - Ruta específica
+   * @returns {Function} Middleware de Express
+   */
+  routeProcessingMiddleware(route) {
+    return (req, res, next) => {
+      // Disparar hook antes de procesar la ruta específica
+      this.doAction(`before_route_${route}`, req, res, next);
+      next();
+    };
+  }
+
+  /**
+   * Middleware para disparar hooks después de procesar la ruta
+   * @param {string} route - Ruta específica
+   * @returns {Function} Middleware de Express
+   */
+  routeProcessedMiddleware(route) {
+    return (req, res, next) => {
+      // Guardar la función original de res.send
+      const originalSend = res.send;
+      
+      // Sobrescribir res.send para capturar cuando se envía la respuesta para una ruta específica
+      res.send = function(data) {
+        // Disparar hook antes de enviar la respuesta para la ruta específica
+        this.doAction(`after_route_${route}`, req, res, data);
+        
+        // Llamar a la función original
+        return originalSend.call(res, data);
+      }.bind(this);
+      
+      next();
+    };
+  }
+
+  /**
+   * Método para iniciar la integración con Express
+   */
+  init() {
+    // Añadir middleware para hooks al inicio de la solicitud
+    this.app.use(this.requestStartedMiddleware());
+    
+    // Añadir middleware para hooks al procesar la solicitud
+    this.app.use(this.requestProcessedMiddleware());
+    
+    // Añadir middleware para manejo de errores
+    this.app.use(this.errorHandlerMiddleware());
+  }
+
+  /**
+   * Método para registrar un hook específico para una ruta
+   * @param {string} route - Ruta específica
+   * @param {string} hookType - Tipo de hook ('before' o 'after')
+   * @param {Function} callback - Callback a ejecutar
+   * @param {number} priority - Prioridad del callback
+   * @param {number} acceptedArgs - Número de argumentos aceptados
+   * @param {string} [identifier] - Identificador opcional
+   */
+  addRouteHook(route, hookType, callback, priority = 10, acceptedArgs = 1, identifier = null) {
+    if (!['before', 'after'].includes(hookType)) {
+      throw new Error('hookType debe ser "before" o "after"');
+    }
+    
+    // Determinar el nombre del hook según el tipo
+    const hookName = hookType === 'before' 
+      ? `before_route_${route.replace(/\//g, '_')}` 
+      : `after_route_${route.replace(/\//g, '_')}`;
+      
+    this.addAction(hookName, callback, priority, acceptedArgs, identifier);
+  }
+
+  /**
+   * Método para registrar un middleware específico para una ruta
+   * @param {string} method - Método HTTP (GET, POST, etc.)
+   * @param {string} route - Ruta específica
+   * @param {...Function} middlewares - Middlewares a aplicar
+   */
+  addRouteMiddleware(method, route, ...middlewares) {
+    // Añadir middlewares antes de la ruta específica
+    this.app[method.toLowerCase()](route, ...middlewares);
+  }
+
+  /**
+   * Método para extender la funcionalidad de Express con hooks
+   * @param {string} methodName - Nombre del método a extender
+   * @param {Function} wrapperFn - Función que envuelve la funcionalidad original
+   */
+  extendExpressMethod(methodName, wrapperFn) {
+    if (this.app && typeof this.app[methodName] === 'function') {
+      const originalMethod = this.app[methodName];
+      this.app[methodName] = wrapperFn(originalMethod);
+    }
+  }
+}
+
+module.exports = ExpressHooked;