jerkjs 2.4.0 → 2.5.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # CHANGELOG
 
+## v2.5.0 - 6 de febrero de 2026
+
+### Added
+- **RouteDirectoryLoader**: Nuevo componente `RouteDirectoryLoader` que permite cargar rutas desde múltiples archivos JSON ubicados en un directorio específico
+- **Detección de rutas duplicadas**: El sistema ahora detecta automáticamente cuando una ruta sobrescribe otra y muestra mensajes de advertencia
+- **Mensajes de log coloreados**: Mensajes en rojo para rutas sobreescritas y en amarillo para rutas que prevalecen
+- **Integración con sistema de hooks**: El nuevo componente dispara eventos en momentos clave del proceso de carga de rutas
+- **Recarga automática de rutas**: Funcionalidad para observar cambios en los archivos de rutas y recargar automáticamente
+- **Manual de uso**: Documentación completa para el nuevo componente RouteDirectoryLoader
+
+### Changed
+- **Actualización de la versión a 2.5.0**: Debido a la implementación significativa del componente RouteDirectoryLoader
+- **Exportaciones del framework actualizadas**: Se ha añadido la nueva exportación de RouteDirectoryLoader en el archivo principal index.js
+
+## v2.4.1 - 22 de enero de 2026
+
+### Changed
+- **QueryBuilder ahora como dependencia externa**: El componente QueryBuilder ha sido removido como parte interna del framework y ahora es una dependencia externa llamada `qbuilderjs`. Esto permite una mayor modularidad y mantenimiento independiente del componente.
+
 ## v2.3.1 - 21 de enero de 2026
 
 ### Fixed

package/README.md

@@ -1,6 +1,6 @@
-# JERK Framework v2.3.1
+# JERK Framework v2.5.0
 
-![JERK Framework Logo](jerk.webg)
+![JERK Framework Logo](jerk.webp)
 
 **¿Nuevo en JERK? Comienza tu proyecto rápidamente con nuestro Starter Kit**
 
@@ -13,7 +13,7 @@ Nuestro Starter Kit en `standard/server.js` es la forma más rápida de comenzar
 - Middlewares esenciales ya integrados (autenticación, CORS, compresión, firewall, etc.)
 - Sistema de logging y manejo de errores implementado
 - **NUEVO: Arquitectura completa MVC con modelos y soporte para bases de datos**
-- **NUEVO: QueryBuilder con API fluida para consultas SQL seguras y eficientes**
+- **NUEVO: Compatible con qbuilderjs para consultas SQL seguras y eficientes**
 
 **Cómo comenzar:**
 1. Edita el archivo `routes.json` para definir tus rutas y asociarlas a tus controladores
@@ -106,6 +106,84 @@ server.addRoute('GET', '/assets', {
 });
 ```
 
+## Carga de Rutas desde Múltiples Archivos (v2.5.0)
+
+Desde la versión 2.5.0, JERK Framework incluye el componente `RouteDirectoryLoader` que permite cargar rutas desde múltiples archivos JSON ubicados en un directorio específico. Esta funcionalidad mejora la organización y mantenibilidad de aplicaciones grandes al permitir dividir las rutas en varios archivos en lugar de tener un único archivo `routes.json`.
+
+### Ventajas del RouteDirectoryLoader:
+- Organización por funcionalidad (usuarios, autenticación, API, etc.)
+- Mayor mantenibilidad en proyectos grandes
+- Detección automática de rutas duplicadas
+- Mensajes de advertencia coloreados para rutas sobreescritas
+- Recarga automática de rutas en desarrollo
+
+### Uso del RouteDirectoryLoader:
+
+```javascript
+const { APIServer, RouteDirectoryLoader } = require('jerkjs');
+
+const server = new APIServer({ port: 3000 });
+const routeDirectoryLoader = new RouteDirectoryLoader();
+
+// Cargar rutas desde un directorio que contiene múltiples archivos JSON
+routeDirectoryLoader.loadRoutesFromDirectory(server, './routes')
+  .then(routes => {
+    console.log(`${routes.length} rutas cargadas exitosamente`);
+    server.start();
+  })
+  .catch(error => {
+    console.error('Error cargando rutas desde directorio:', error.message);
+  });
+```
+
+### Estructura de directorio recomendada:
+```
+routes/
+├── api-routes.json
+├── auth-routes.json
+├── static-routes.json
+└── user-routes.json
+```
+
+### Ejemplo de archivo api-routes.json:
+```json
+[
+  {
+    "path": "/api/users",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getAllUsers",
+    "contentType": "application/json"
+  },
+  {
+    "path": "/api/users/:id",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getUserById",
+    "contentType": "application/json"
+  }
+]
+```
+
+### Detección de rutas duplicadas:
+Cuando el sistema detecta que una ruta ya ha sido definida previamente, muestra mensajes de advertencia:
+
+```
+[RUTA SOBREESCRITA] Archivo: ./routes/api-routes.json, Ruta: GET /users
+[RUTA ACTUAL] Archivo: ./routes/other-routes.json, Ruta: GET /users
+```
+
+- El mensaje en **rojo** indica la ruta que será sobreescrita
+- El mensaje en **amarillo** indica la ruta que prevalece
+
+### Recarga automática de rutas:
+Durante el desarrollo, puedes habilitar la recarga automática cuando se modifican los archivos de rutas:
+
+```javascript
+// Observar cambios en el directorio de rutas
+routeDirectoryLoader.watchRoutesDirectory(server, './routes', 1000); // 1000ms debounce
+```
+
 Visita nuestra página web: https://jerk.page.gd/
 Repositorio oficial: https://gitlab.com/bytedogssyndicate1/jerk/
 
@@ -126,8 +204,7 @@ Repositorio oficial: https://gitlab.com/bytedogssyndicate1/jerk/
 - **Motor de Plantillas MVC**: Sistema profesional de vistas con soporte para filtros, helpers y hooks
 - **Arquitectura de Modelos Completa (MVC)**: Capa de modelos para la lógica de negocio y acceso a datos
 - **Sistema de Adaptadores de Base de Datos**: Soporte para múltiples motores de base de datos (MariaDB, MySQL, etc.)
-- **QueryBuilder con API Fluida**: Interfaz para construir consultas SQL complejas de manera segura y eficiente
-- **Middleware de QueryBuilder**: Sistema para inyectar QueryBuilder en solicitudes HTTP con soporte para hooks
+- **Compatible con qbuilderjs**: Soporte para integrar el QueryBuilder externo qbuilderjs para construir consultas SQL complejas de manera segura y eficiente
 - **Servicio de Archivos Estáticos**: Soporte para servir archivos desde directorios locales con configuración flexible
 - **Extensibilidad**: Sistema de hooks y filters para personalización
 

package/docs/ROUTE_DIRECTORY_LOADER_MANUAL.md

@@ -0,0 +1,277 @@
+# Manual de Uso de la Extensión RouteDirectoryLoader
+
+## Descripción General
+
+El componente `RouteDirectoryLoader` es una extensión del framework JerkJS que permite cargar rutas desde múltiples archivos JSON ubicados en un directorio específico. Esta extensión mejora la organización y mantenibilidad de aplicaciones grandes al permitir dividir las rutas en varios archivos en lugar de tener un único archivo `routes.json`.
+
+## Características Principales
+
+### 1. Carga de Rutas desde Directorio
+- Carga múltiples archivos JSON de rutas desde un directorio
+- Compatible con la estructura estándar de rutas de JerkJS
+- Soporta todas las funcionalidades disponibles en `routes.json`
+
+### 2. Detección de Rutas Duplicadas
+- Identifica automáticamente rutas que se sobrescriben
+- Muestra mensajes de advertencia en colores distintivos:
+  - **Rojo**: Ruta que será sobreescrita
+  - **Amarillo**: Ruta que prevalece
+
+### 3. Integración con el Sistema de Hooks
+- Dispara eventos en momentos clave del proceso de carga
+- Permite extender la funcionalidad mediante hooks personalizados
+
+### 4. Recarga Automática
+- Opción para observar cambios en los archivos de rutas
+- Recarga automática cuando se detectan modificaciones
+
+## Instalación y Configuración
+
+### Importación del Componente
+
+```javascript
+const { APIServer, RouteDirectoryLoader } = require('jerkjs');
+```
+
+### Creación de Instancia
+
+```javascript
+const routeDirectoryLoader = new RouteDirectoryLoader();
+```
+
+## Uso Básico
+
+### Cargar Rutas desde un Directorio
+
+```javascript
+const server = new APIServer({ port: 3000 });
+const routeDirectoryLoader = new RouteDirectoryLoader();
+
+// Directorio que contiene los archivos JSON de rutas
+const routesDirectory = './routes';
+
+// Cargar rutas desde el directorio
+routeDirectoryLoader.loadRoutesFromDirectory(server, routesDirectory)
+  .then(routes => {
+    console.log(`${routes.length} rutas cargadas exitosamente`);
+    server.start();
+  })
+  .catch(error => {
+    console.error('Error cargando rutas desde directorio:', error.message);
+  });
+```
+
+## Estructura de Directorio de Rutas
+
+Organiza tus archivos de rutas en un directorio como este:
+
+```
+routes/
+├── api-routes.json
+├── auth-routes.json
+├── static-routes.json
+└── user-routes.json
+```
+
+Cada archivo contiene rutas en el formato estándar de JerkJS:
+
+**api-routes.json:**
+```json
+[
+  {
+    "path": "/api/users",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getAllUsers",
+    "contentType": "application/json"
+  },
+  {
+    "path": "/api/users/:id",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getUserById",
+    "contentType": "application/json"
+  }
+]
+```
+
+**auth-routes.json:**
+```json
+[
+  {
+    "path": "/login",
+    "method": "GET",
+    "controller": "./controllers/authController.js",
+    "handler": "showLoginPage",
+    "contentType": "text/html"
+  },
+  {
+    "path": "/api/login",
+    "method": "POST",
+    "controller": "./controllers/authController.js",
+    "handler": "processLogin",
+    "contentType": "application/json"
+  }
+]
+```
+
+## Detección de Rutas Duplicadas
+
+Cuando el sistema detecta que una ruta ya ha sido definida previamente, muestra mensajes de advertencia:
+
+```
+[RUTA SOBREESCRITA] Archivo: ./routes/api-routes.json, Ruta: GET /users
+[RUTA ACTUAL] Archivo: ./routes/other-routes.json, Ruta: GET /users
+```
+
+- El mensaje en **rojo** indica la ruta que será sobreescrita
+- El mensaje en **amarillo** indica la ruta que prevalece
+
+## Integración con Hooks
+
+El componente dispara varios eventos que puedes interceptar:
+
+### Hooks Disponibles
+
+- `pre_directory_route_load`: Antes de cargar rutas desde un directorio
+- `pre_file_route_load`: Antes de cargar rutas desde un archivo
+- `route_duplicate_detected`: Cuando se detecta una ruta duplicada
+- `route_loaded_from_directory`: Después de cargar una ruta desde un archivo
+- `post_directory_route_load`: Después de cargar todas las rutas del directorio
+- `pre_directory_routes_reload`: Antes de recargar rutas desde directorio
+- `post_directory_routes_reload`: Después de recargar rutas desde directorio
+
+### Ejemplo de Uso de Hooks
+
+```javascript
+const { hooks } = require('jerkjs');
+
+// Registrar un hook para detectar rutas duplicadas
+hooks.addAction('route_duplicate_detected', (data) => {
+  console.log('Ruta duplicada detectada:');
+  console.log('Ruta sobreescrita:', data.overwrittenRoute);
+  console.log('Nueva ruta:', data.newRoute);
+});
+
+// Registrar un hook para rutas cargadas
+hooks.addAction('route_loaded_from_directory', (data) => {
+  console.log('Ruta cargada:', data.route.path, data.route.method);
+  console.log('Desde archivo:', data.sourceFile);
+});
+```
+
+## Recarga Automática de Rutas
+
+Para habilitar la recarga automática cuando se modifican los archivos de rutas:
+
+```javascript
+// Observar cambios en el directorio de rutas
+routeDirectoryLoader.watchRoutesDirectory(server, routesDirectory, 1000); // 1000ms debounce
+```
+
+## Métodos Disponibles
+
+### `loadRoutesFromDirectory(server, directoryPath)`
+Carga todas las rutas desde un directorio que contiene archivos JSON.
+
+**Parámetros:**
+- `server`: Instancia del servidor APIServer
+- `directoryPath`: Ruta al directorio que contiene los archivos JSON de rutas
+
+**Retorna:** Promise<Array> - Array de rutas cargadas
+
+### `reloadRoutesFromDirectory(server, directoryPath)`
+Recarga todas las rutas desde un directorio.
+
+**Parámetros:**
+- `server`: Instancia del servidor APIServer
+- `directoryPath`: Ruta al directorio que contiene los archivos JSON de rutas
+
+**Retorna:** Promise<Array> - Array de rutas recargadas
+
+### `getLoadedRoutes()`
+Obtiene las rutas que han sido cargadas.
+
+**Retorna:** Array - Array de rutas cargadas
+
+### `watchRoutesDirectory(server, directoryPath, debounceTime)`
+Observa cambios en los archivos de rutas del directorio y recarga automáticamente.
+
+**Parámetros:**
+- `server`: Instancia del servidor APIServer
+- `directoryPath`: Ruta al directorio que contiene los archivos JSON de rutas
+- `debounceTime`: Tiempo de espera entre recargas en milisegundos (opcional, por defecto 1000)
+
+## Ejemplo Completo
+
+```javascript
+const { APIServer, RouteDirectoryLoader, hooks } = require('jerkjs');
+
+// Crear instancia del servidor
+const server = new APIServer({
+  port: 3000,
+  host: 'localhost'
+});
+
+// Crear instancia del cargador de rutas desde directorio
+const routeDirectoryLoader = new RouteDirectoryLoader();
+
+// Registrar hooks para ver eventos
+hooks.addAction('route_duplicate_detected', (data) => {
+  console.log('Evento: Ruta duplicada detectada');
+  console.log('Ruta sobreescrita:', data.overwrittenRoute);
+  console.log('Nueva ruta:', data.newRoute);
+});
+
+hooks.addAction('route_loaded_from_directory', (data) => {
+  console.log('Evento: Ruta cargada desde directorio');
+  console.log('Ruta:', data.route.path, data.route.method);
+  console.log('Archivo:', data.sourceFile);
+});
+
+// Directorio que contiene los archivos JSON de rutas
+const routesDirectory = './routes';
+
+// Cargar rutas desde el directorio
+routeDirectoryLoader.loadRoutesFromDirectory(server, routesDirectory)
+  .then(routes => {
+    console.log(`${routes.length} rutas cargadas exitosamente desde el directorio`);
+    
+    // Iniciar el servidor
+    server.start();
+    
+    // Opcional: Observar cambios en el directorio de rutas
+    routeDirectoryLoader.watchRoutesDirectory(server, routesDirectory);
+  })
+  .catch(error => {
+    console.error('Error cargando rutas desde directorio:', error.message);
+  });
+```
+
+## Buenas Prácticas
+
+1. **Organización por Funcionalidad**: Divide tus rutas en archivos según su funcionalidad (usuarios, autenticación, API, etc.)
+
+2. **Evitar Rutas Duplicadas**: Asegúrate de que no haya rutas duplicadas a menos que sea intencional
+
+3. **Uso de Hooks**: Utiliza los hooks para registrar eventos y monitorizar la carga de rutas
+
+4. **Recarga en Desarrollo**: Usa la funcionalidad de recarga automática durante el desarrollo para mejorar la experiencia de desarrollo
+
+5. **Estructura Consistente**: Mantén una estructura consistente en todos tus archivos de rutas
+
+## Consideraciones de Seguridad
+
+- Asegúrate de que el directorio de rutas esté protegido contra escritura no autorizada
+- Valida que los archivos JSON tengan la estructura correcta antes de cargarlos
+- Considera usar permisos restrictivos en producción para los archivos de configuración
+
+## Compatibilidad
+
+- Compatible con todas las funcionalidades de `routes.json`
+- Compatible con autenticación por ruta
+- Compatible con content-type por ruta
+- Compatible con rutas estáticas
+- Compatible con el sistema de hooks del framework
+
+Esta extensión proporciona una solución robusta y escalable para gestionar rutas en aplicaciones JerkJS de gran tamaño, manteniendo la organización y facilitando la detección de conflictos.

package/example-directory-loader.js

@@ -0,0 +1,46 @@
+/**
+ * Ejemplo de uso del componente RouteDirectoryLoader
+ * Este ejemplo demuestra cómo cargar rutas desde un directorio con múltiples archivos JSON
+ */
+
+const { APIServer, RouteDirectoryLoader, hooks } = require('./index.js');
+
+// Crear instancia del servidor
+const server = new APIServer({
+  port: 3000,
+  host: 'localhost'
+});
+
+// Crear instancia del cargador de rutas desde directorio
+const routeDirectoryLoader = new RouteDirectoryLoader();
+
+// Registrar hooks para ver eventos
+hooks.addAction('route_duplicate_detected', (data) => {
+  console.log('Evento: Ruta duplicada detectada');
+  console.log('Ruta sobreescrita:', data.overwrittenRoute);
+  console.log('Nueva ruta:', data.newRoute);
+});
+
+hooks.addAction('route_loaded_from_directory', (data) => {
+  console.log('Evento: Ruta cargada desde directorio');
+  console.log('Ruta:', data.route.path, data.route.method);
+  console.log('Archivo:', data.sourceFile);
+});
+
+// Directorio que contiene los archivos JSON de rutas
+const routesDirectory = './routes';
+
+// Cargar rutas desde el directorio
+routeDirectoryLoader.loadRoutesFromDirectory(server, routesDirectory)
+  .then(routes => {
+    console.log(`${routes.length} rutas cargadas exitosamente desde el directorio`);
+    
+    // Iniciar el servidor
+    server.start();
+  })
+  .catch(error => {
+    console.error('Error cargando rutas desde directorio:', error.message);
+  });
+
+// Opcional: Observar cambios en el directorio de rutas
+// routeDirectoryLoader.watchRoutesDirectory(server, routesDirectory);

package/index.js

@@ -1,6 +1,6 @@
 /**
  * Punto de entrada del framework JERK
- * JERK Framework 2.1.8
+ * JERK Framework 2.5.0
  */
 
 // Mostrar mensaje de versión al iniciar
@@ -13,6 +13,7 @@ const HandlerManager = require('./lib/core/handler');
 const Authenticator = require('./lib/middleware/authenticator');
 const Validator = require('./lib/middleware/validator');
 const RouteLoader = require('./lib/loader/routeLoader');
+const RouteDirectoryLoader = require('./lib/loader/routeDirectoryLoader');
 const ControllerLoader = require('./lib/loader/controllerLoader');
 const ConfigParser = require('./lib/utils/configParser');
 const { Logger } = require('./lib/utils/logger');
@@ -61,6 +62,7 @@ module.exports = {
   Authenticator,
   Validator,
   RouteLoader,
+  RouteDirectoryLoader,
   ControllerLoader,
   ConfigParser,
   Logger,

package/lib/loader/routeDirectoryLoader.js

@@ -0,0 +1,294 @@
+/**
+ * Carga de rutas desde múltiples archivos JSON en un directorio para el framework JERK
+ * Implementación del componente loader/routeDirectoryLoader.js
+ * JERK Framework v2.5.0 - Con detección de rutas duplicadas y mensajes de log coloreados
+ */
+
+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 {Object} server - Instancia del servidor
+   * @param {string} directoryPath - Ruta al directorio que contiene los archivos JSON de rutas
+   * @returns {Promise<Array>} - Array de rutas cargadas
+   */
+  async loadRoutesFromDirectory(server, directoryPath) {
+    try {
+      // Disparar hook antes de cargar rutas desde directorio
+      const hooks = require('../../index.js').hooks;
+      if (hooks) {
+        const hookResult = hooks.applyFilters('pre_directory_route_load', {
+          directoryPath,
+          server,
+          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(server, filePath);
+      }
+
+      // Disparar hook después de cargar rutas desde directorio
+      if (hooks) {
+        hooks.doAction('post_directory_route_load', this.loadedRoutes, server);
+      }
+
+      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 {Object} server - Instancia del servidor
+   * @param {string} filePath - Ruta al archivo JSON de rutas
+   */
+  async loadRoutesFromFile(server, filePath) {
+    try {
+      // Disparar hook antes de cargar archivo
+      const hooks = require('../../index.js').hooks;
+      if (hooks) {
+        const hookResult = hooks.applyFilters('pre_file_route_load', {
+          filePath,
+          server,
+          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(server, 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 {Object} server - Instancia del servidor
+   * @param {Object} route - Objeto de ruta a cargar
+   * @param {string} sourceFile - Archivo del que proviene la ruta
+   */
+  async loadSingleRoute(server, 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 = require('../../index.js').hooks;
+      if (hooks) {
+        hooks.doAction('route_duplicate_detected', {
+          overwrittenRoute: existingRouteInfo,
+          newRoute: { route, sourceFile },
+          server
+        });
+      }
+      
+      // Mostrar mensaje de advertencia con colores
+      console.log('\x1b[31m%s\x1b[0m', `[RUTA SOBREESCRITA] Archivo: ${existingRouteInfo.sourceFile}, Ruta: ${route.method.toUpperCase()} ${route.path}`);
+      console.log('\x1b[33m%s\x1b[0m', `[RUTA ACTUAL] Archivo: ${sourceFile}, Ruta: ${route.method.toUpperCase()} ${route.path}`);
+    }
+
+    // Agregar la ruta al mapa con su archivo de origen
+    this.routeMap.set(routeKey, {
+      route: { ...route },
+      sourceFile
+    });
+
+    // Cargar la ruta en el servidor
+    const routeLoader = new RouteLoader();
+    await routeLoader.loadSingleRoute(server, route);
+
+    // Disparar hook después de cargar la ruta
+    const hooks = require('../../index.js').hooks;
+    if (hooks) {
+      hooks.doAction('route_loaded_from_directory', { route, sourceFile, server });
+    }
+
+    // Agregar la ruta a las rutas cargadas
+    this.loadedRoutes.push({
+      ...route,
+      sourceFile
+    });
+  }
+
+  /**
+   * Método para recargar rutas desde un directorio
+   * @param {Object} server - Instancia del servidor
+   * @param {string} directoryPath - Ruta al directorio que contiene los archivos JSON de rutas
+   * @returns {Promise<Array>} - Array de rutas recargadas
+   */
+  async reloadRoutesFromDirectory(server, directoryPath) {
+    // Limpiar rutas previamente cargadas
+    this.loadedRoutes = [];
+    this.routeMap.clear();
+
+    // Cargar rutas nuevamente
+    return await this.loadRoutesFromDirectory(server, 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 {Object} server - Instancia del servidor
+   * @param {string} directoryPath - Ruta al directorio que contiene los archivos JSON de rutas
+   * @param {number} debounceTime - Tiempo de espera entre recargas (milisegundos)
+   */
+  watchRoutesDirectory(server, 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 = require('../../index.js').hooks;
+            if (hooks) {
+              hooks.doAction('pre_directory_routes_reload', directoryPath, server);
+            }
+            
+            await this.reloadRoutesFromDirectory(server, directoryPath);
+            console.log('Rutas recargadas exitosamente');
+            
+            // Disparar hook después de recargar
+            if (hooks) {
+              hooks.doAction('post_directory_routes_reload', this.loadedRoutes, server);
+            }
+          } catch (error) {
+            console.error('Error recargando rutas:', error.message);
+          }
+        }, debounceTime);
+      }
+    });
+  }
+}
+
+module.exports = RouteDirectoryLoader;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jerkjs",
-  "version": "2.4.0",
-  "description": "JERK Framework v2.3.1 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, template engine, QueryBuilder, and complete MVC architecture with models",
+  "version": "2.5.0",
+  "description": "JERK Framework v2.5.0 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, template engine, integration with qbuilderjs, complete MVC architecture with models, and enhanced route loading from directory",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",