expressed-core 1.0.0

package/router/RouteDirectoryLoader.js

@@ -0,0 +1,299 @@
+/**
+ * Carga de rutas desde múltiples archivos JSON en un directorio para Express-Router
+ * Express-Router v1.0.0 - Carga de rutas desde directorio
+ */
+
+const fs = require('fs');
+const path = require('path');
+const RouteLoader = require('./RouteLoader');
+
+class RouteDirectoryLoader {
+  /**
+   * Constructor del cargador de rutas desde directorio
+   */
+  constructor() {
+    this.loadedRoutes = [];
+    this.routeMap = new Map(); // Para detectar rutas duplicadas
+  }
+
+  /**
+   * Método para cargar rutas desde un directorio que contiene múltiples archivos JSON
+   * @param {ExpressRouterIntegration} routerIntegration - Instancia de la integración del router
+   * @param {string} directoryPath - Ruta al directorio que contiene los archivos JSON de rutas
+   * @returns {Promise<Array>} - Array de rutas cargadas
+   */
+  async loadRoutesFromDirectory(routerIntegration, directoryPath) {
+    try {
+      // Disparar hook antes de cargar rutas desde directorio
+      const hooks = routerIntegration.getHooks();
+      if (hooks) {
+        const hookResult = hooks.applyFilters('pre_directory_route_load', {
+          directoryPath,
+          routerIntegration,
+          shouldContinue: true
+        });
+
+        if (!hookResult.shouldContinue) {
+          return []; // Cancelar proceso si el filtro lo indica
+        }
+
+        directoryPath = hookResult.directoryPath || directoryPath;
+      }
+
+      // Verificar si el directorio existe
+      if (!fs.existsSync(directoryPath)) {
+        throw new Error(`Directorio de rutas no encontrado: ${directoryPath}`);
+      }
+
+      // Obtener todos los archivos JSON del directorio
+      const files = fs.readdirSync(directoryPath).filter(file =>
+        path.extname(file).toLowerCase() === '.json'
+      );
+
+      if (files.length === 0) {
+        console.log(`No se encontraron archivos JSON en el directorio: ${directoryPath}`);
+        return [];
+      }
+
+      // Cargar cada archivo JSON
+      for (const file of files) {
+        const filePath = path.join(directoryPath, file);
+        await this.loadRoutesFromFile(routerIntegration, filePath);
+      }
+
+      // Disparar hook después de cargar rutas desde directorio
+      if (hooks) {
+        hooks.doAction('post_directory_route_load', this.loadedRoutes, routerIntegration);
+      }
+
+      return this.loadedRoutes;
+    } catch (error) {
+      throw new Error(`Error cargando rutas desde directorio ${directoryPath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Método para cargar rutas desde un archivo JSON individual
+   * @param {ExpressRouterIntegration} routerIntegration - Instancia de la integración del router
+   * @param {string} filePath - Ruta al archivo JSON de rutas
+   */
+  async loadRoutesFromFile(routerIntegration, filePath) {
+    try {
+      // Disparar hook antes de cargar archivo
+      const hooks = routerIntegration.getHooks();
+      if (hooks) {
+        const hookResult = hooks.applyFilters('pre_file_route_load', {
+          filePath,
+          routerIntegration,
+          shouldContinue: true
+        });
+
+        if (!hookResult.shouldContinue) {
+          return; // Cancelar proceso si el filtro lo indica
+        }
+
+        filePath = hookResult.filePath || filePath;
+      }
+
+      // Verificar si el archivo existe
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Archivo de rutas no encontrado: ${filePath}`);
+      }
+
+      // Leer y parsear el archivo JSON
+      const routeData = fs.readFileSync(filePath, 'utf8');
+      const routes = JSON.parse(routeData);
+
+      // Validar estructura del archivo de rutas
+      this.validateRoutesStructure(routes);
+
+      // Cargar cada ruta, verificando duplicados
+      for (const route of routes) {
+        await this.loadSingleRoute(routerIntegration, route, filePath);
+      }
+    } catch (error) {
+      throw new Error(`Error cargando rutas desde ${filePath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Método para validar la estructura del archivo de rutas
+   * @param {Array} routes - Array de rutas a validar
+   */
+  validateRoutesStructure(routes) {
+    if (!Array.isArray(routes)) {
+      throw new Error('El archivo de rutas debe contener un array de rutas');
+    }
+
+    for (let i = 0; i < routes.length; i++) {
+      const route = routes[i];
+
+      if (typeof route !== 'object' || route === null) {
+        throw new Error(`La ruta en la posición ${i} no es un objeto válido`);
+      }
+
+      if (!route.path) {
+        throw new Error(`La ruta en la posición ${i} no tiene propiedad 'path'`);
+      }
+
+      if (!route.method) {
+        throw new Error(`La ruta en la posición ${i} no tiene propiedad 'method'`);
+      }
+
+      // Verificar si es una ruta estática
+      if (route.static) {
+        if (typeof route.static !== 'object' || route.static === null) {
+          throw new Error(`La ruta en la posición ${i} tiene una propiedad 'static' inválida`);
+        }
+
+        if (!route.static.dir) {
+          throw new Error(`La ruta en la posición ${i} tiene una configuración 'static' sin directorio 'dir'`);
+        }
+
+        // El método debe ser GET para rutas estáticas
+        if (route.method.toUpperCase() !== 'GET') {
+          throw new Error(`Las rutas estáticas deben usar el método GET, no ${route.method}`);
+        }
+      } else {
+        // Validación normal para rutas dinámicas
+        if (!route.controller) {
+          throw new Error(`La ruta en la posición ${i} no tiene propiedad 'controller'`);
+        }
+
+        if (!route.handler) {
+          throw new Error(`La ruta en la posición ${i} no tiene propiedad 'handler'`);
+        }
+      }
+
+      // Validar que el content-type sea un string si está presente
+      if (route.contentType && typeof route.contentType !== 'string') {
+        throw new Error(`La ruta en la posición ${i} tiene un 'contentType' inválido, debe ser un string`);
+      }
+    }
+  }
+
+  /**
+   * Método para cargar una sola ruta, verificando si ya existe
+   * @param {ExpressRouterIntegration} routerIntegration - Instancia de la integración del router
+   * @param {Object} route - Objeto de ruta a cargar
+   * @param {string} sourceFile - Archivo del que proviene la ruta
+   */
+  async loadSingleRoute(routerIntegration, route, sourceFile) {
+    // Crear un identificador único para la ruta (método + path)
+    const routeKey = `${route.method.toUpperCase()}-${route.path}`;
+
+    // Verificar si ya existe una ruta con el mismo método y path
+    if (this.routeMap.has(routeKey)) {
+      const existingRouteInfo = this.routeMap.get(routeKey);
+
+      // Disparar hook antes de sobrescribir ruta
+      const hooks = routerIntegration.getHooks();
+      if (hooks) {
+        hooks.doAction('route_duplicate_detected', {
+          overwrittenRoute: existingRouteInfo,
+          newRoute: { route, sourceFile },
+          routerIntegration
+        });
+      }
+
+      // Mostrar mensaje de advertencia
+      console.log(`[RUTA SOBREESCRITA] Archivo: ${existingRouteInfo.sourceFile}, Ruta: ${route.method.toUpperCase()} ${route.path}`);
+      console.log(`[RUTA ACTUAL] Archivo: ${sourceFile}, Ruta: ${route.method.toUpperCase()} ${route.path}`);
+
+      // Actualizar la ruta en el mapa con la nueva información
+      this.routeMap.set(routeKey, {
+        route: { ...route },
+        sourceFile
+      });
+    } else {
+      // Agregar la ruta al mapa con su archivo de origen
+      this.routeMap.set(routeKey, {
+        route: { ...route },
+        sourceFile
+      });
+    }
+
+    // Cargar la ruta en el router
+    const routeLoader = new RouteLoader();
+    await routeLoader.loadSingleRoute(routerIntegration, route);
+
+    // Disparar hook después de cargar la ruta
+    const hooks = routerIntegration.getHooks();
+    if (hooks) {
+      hooks.doAction('route_loaded_from_directory', { route, sourceFile, routerIntegration });
+    }
+
+    // Agregar la ruta a las rutas cargadas
+    this.loadedRoutes.push({
+      ...route,
+      sourceFile
+    });
+  }
+
+  /**
+   * Método para recargar rutas desde un directorio
+   * @param {ExpressRouterIntegration} routerIntegration - Instancia de la integración del router
+   * @param {string} directoryPath - Ruta al directorio que contiene los archivos JSON de rutas
+   * @returns {Promise<Array>} - Array de rutas recargadas
+   */
+  async reloadRoutesFromDirectory(routerIntegration, directoryPath) {
+    // Limpiar rutas previamente cargadas
+    this.loadedRoutes = [];
+    this.routeMap.clear();
+
+    // Cargar rutas nuevamente
+    return await this.loadRoutesFromDirectory(routerIntegration, directoryPath);
+  }
+
+  /**
+   * Método para obtener las rutas cargadas
+   * @returns {Array} - Array de rutas cargadas
+   */
+  getLoadedRoutes() {
+    return this.loadedRoutes;
+  }
+
+  /**
+   * Método para observar cambios en los archivos de rutas del directorio y recargar automáticamente
+   * @param {ExpressRouterIntegration} routerIntegration - Instancia de la integración del router
+   * @param {string} directoryPath - Ruta al directorio que contiene los archivos JSON de rutas
+   * @param {number} debounceTime - Tiempo de espera entre recargas (milisegundos)
+   */
+  watchRoutesDirectory(routerIntegration, directoryPath, debounceTime = 1000) {
+    if (!fs.existsSync(directoryPath)) {
+      throw new Error(`Directorio de rutas no encontrado: ${directoryPath}`);
+    }
+
+    let timeoutId;
+
+    // Observar cambios en el directorio
+    fs.watch(directoryPath, (eventType, filename) => {
+      if (filename && path.extname(filename).toLowerCase() === '.json') {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(async () => {
+          try {
+            console.log(`Recargando rutas desde directorio: ${directoryPath}`);
+
+            // Disparar hook antes de recargar
+            const hooks = routerIntegration.getHooks();
+            if (hooks) {
+              hooks.doAction('pre_directory_routes_reload', directoryPath, routerIntegration);
+            }
+
+            await this.reloadRoutesFromDirectory(routerIntegration, directoryPath);
+            console.log('Rutas recargadas exitosamente');
+
+            // Disparar hook después de recargar
+            if (hooks) {
+              hooks.doAction('post_directory_routes_reload', this.loadedRoutes, routerIntegration);
+            }
+          } catch (error) {
+            console.error('Error recargando rutas:', error.message);
+          }
+        }, debounceTime);
+      }
+    });
+  }
+}
+
+module.exports = RouteDirectoryLoader;

package/router/RouteLoader.js

@@ -0,0 +1,245 @@
+/**
+ * Carga de rutas desde archivos JSON para Express-Router
+ * Express-Router v1.0.0 - Carga de rutas desde archivos JSON
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class RouteLoader {
+  /**
+   * Constructor del cargador de rutas
+   */
+  constructor() {
+    this.loadedRoutes = [];
+  }
+
+  /**
+   * Método para cargar rutas desde un archivo JSON
+   * @param {ExpressRouterIntegration} routerIntegration - Instancia de la integración del router
+   * @param {string} filePath - Ruta al archivo JSON de rutas
+   * @returns {Promise<Array>} - Array de rutas cargadas
+   */
+  async loadRoutes(routerIntegration, filePath) {
+    try {
+      // Disparar hook antes de cargar rutas
+      const hooks = routerIntegration.getHooks();
+      if (hooks) {
+        hooks.doAction('pre_route_load', filePath, routerIntegration);
+      }
+
+      // Verificar si el archivo existe
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Archivo de rutas no encontrado: ${filePath}`);
+      }
+
+      // Leer y parsear el archivo JSON
+      const routeData = fs.readFileSync(filePath, 'utf8');
+      const routes = JSON.parse(routeData);
+
+      // Validar estructura del archivo de rutas
+      this.validateRoutesStructure(routes);
+
+      // Cargar cada ruta
+      for (const route of routes) {
+        await this.loadSingleRoute(routerIntegration, route);
+      }
+
+      this.loadedRoutes = [...this.loadedRoutes, ...routes];
+
+      // Disparar hook después de cargar rutas
+      if (hooks) {
+        hooks.doAction('post_route_load', routes, routerIntegration);
+      }
+
+      return routes;
+    } catch (error) {
+      throw new Error(`Error cargando rutas desde ${filePath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Método para validar la estructura del archivo de rutas
+   * @param {Array} routes - Array de rutas a validar
+   */
+  validateRoutesStructure(routes) {
+    if (!Array.isArray(routes)) {
+      throw new Error('El archivo de rutas debe contener un array de rutas');
+    }
+
+    for (let i = 0; i < routes.length; i++) {
+      const route = routes[i];
+
+      if (typeof route !== 'object' || route === null) {
+        throw new Error(`La ruta en la posición ${i} no es un objeto válido`);
+      }
+
+      if (!route.path) {
+        throw new Error(`La ruta en la posición ${i} no tiene propiedad 'path'`);
+      }
+
+      if (!route.method) {
+        throw new Error(`La ruta en la posición ${i} no tiene propiedad 'method'`);
+      }
+
+      // Verificar si es una ruta estática
+      if (route.static) {
+        if (typeof route.static !== 'object' || route.static === null) {
+          throw new Error(`La ruta en la posición ${i} tiene una propiedad 'static' inválida`);
+        }
+
+        if (!route.static.dir) {
+          throw new Error(`La ruta en la posición ${i} tiene una configuración 'static' sin directorio 'dir'`);
+        }
+
+        // El método debe ser GET para rutas estáticas
+        if (route.method.toUpperCase() !== 'GET') {
+          throw new Error(`Las rutas estáticas deben usar el método GET, no ${route.method}`);
+        }
+      } else {
+        // Validación normal para rutas dinámicas
+        if (!route.controller) {
+          throw new Error(`La ruta en la posición ${i} no tiene propiedad 'controller'`);
+        }
+
+        if (!route.handler) {
+          throw new Error(`La ruta en la posición ${i} no tiene propiedad 'handler'`);
+        }
+      }
+
+      // Validar que el content-type sea un string si está presente
+      if (route.contentType && typeof route.contentType !== 'string') {
+        throw new Error(`La ruta en la posición ${i} tiene un 'contentType' inválido, debe ser un string`);
+      }
+    }
+  }
+
+  /**
+   * Método para cargar una sola ruta
+   * @param {ExpressRouterIntegration} routerIntegration - Instancia de la integración del router
+   * @param {Object} route - Objeto de ruta a cargar
+   */
+  async loadSingleRoute(routerIntegration, route) {
+    // Verificar si es una ruta estática
+    if (route.static) {
+      // Para rutas estáticas, crear un handler que sirva archivos estáticos
+      const staticHandler = this.createStaticHandler(route.static.dir, route.static.options || {});
+      
+      routerIntegration.addRoute(route.method, route.path, staticHandler);
+    } else {
+      // Lógica para rutas dinámicas
+      // Obtener el controlador
+      // Si la ruta del controlador es relativa, resolverla desde el directorio actual
+      let controllerPath;
+      if (route.controller.startsWith('./') || route.controller.startsWith('../')) {
+        controllerPath = path.resolve(process.cwd(), route.controller);
+      } else {
+        controllerPath = path.resolve(process.cwd(), route.controller);
+      }
+      
+      let controllerModule;
+
+      try {
+        controllerModule = require(controllerPath);
+      } catch (error) {
+        throw new Error(`No se pudo cargar el controlador: ${route.controller}. Error: ${error.message}`);
+      }
+
+      // Obtener el handler del controlador
+      const handler = controllerModule[route.handler];
+      if (typeof handler !== 'function') {
+        throw new Error(`El handler '${route.handler}' no es una función en el controlador: ${route.controller}`);
+      }
+
+      // Crear un handler que establezca el content-type si está especificado
+      let finalHandler = handler;
+
+      if (route.contentType) {
+        finalHandler = async (req, res, next) => {
+          // Establecer el content-type antes de ejecutar el handler original
+          res.setHeader('Content-Type', route.contentType);
+
+          // Si el handler es asíncrono, esperarlo
+          if (handler.constructor.name === 'AsyncFunction') {
+            await handler(req, res, next);
+          } else {
+            handler(req, res, next);
+          }
+        };
+      }
+
+      // Agregar la ruta con el handler final
+      routerIntegration.addRoute(route.method, route.path, finalHandler);
+    }
+  }
+
+  /**
+   * Método para crear un handler de archivos estáticos
+   * @param {string} dir - Directorio de archivos estáticos
+   * @param {Object} options - Opciones para servir archivos estáticos
+   * @returns {Function} - Handler de Express para archivos estáticos
+   */
+  createStaticHandler(dir, options = {}) {
+    const serveStatic = require('serve-static');
+    const serve = serveStatic(dir, options);
+
+    return (req, res, next) => {
+      // Disparar hook antes de servir archivo estático
+      // (esto se haría si tuviéramos acceso a los hooks aquí)
+      serve(req, res, next);
+    };
+  }
+
+  /**
+   * Método para recargar rutas desde un archivo
+   * @param {ExpressRouterIntegration} routerIntegration - Instancia de la integración del router
+   * @param {string} filePath - Ruta al archivo JSON de rutas
+   * @returns {Promise<Array>} - Array de rutas recargadas
+   */
+  async reloadRoutes(routerIntegration, filePath) {
+    // Limpiar rutas previamente cargadas
+    this.loadedRoutes = [];
+
+    // Cargar rutas nuevamente
+    return await this.loadRoutes(routerIntegration, filePath);
+  }
+
+  /**
+   * Método para obtener las rutas cargadas
+   * @returns {Array} - Array de rutas cargadas
+   */
+  getLoadedRoutes() {
+    return this.loadedRoutes;
+  }
+
+  /**
+   * Método para observar cambios en el archivo de rutas y recargar automáticamente
+   * @param {ExpressRouterIntegration} routerIntegration - Instancia de la integración del router
+   * @param {string} filePath - Ruta al archivo JSON de rutas
+   * @param {number} debounceTime - Tiempo de espera entre recargas (milisegundos)
+   */
+  watchRoutes(routerIntegration, filePath, debounceTime = 1000) {
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Archivo de rutas no encontrado: ${filePath}`);
+    }
+
+    let timeoutId;
+
+    fs.watch(filePath, (eventType) => {
+      if (eventType === 'change') {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(async () => {
+          try {
+            console.log(`Recargando rutas desde: ${filePath}`);
+            await this.reloadRoutes(routerIntegration, filePath);
+            console.log('Rutas recargadas exitosamente');
+          } catch (error) {
+            console.error('Error recargando rutas:', error.message);
+          }
+        }, debounceTime);
+      }
+    });
+  }
+}
+
+module.exports = RouteLoader;