jerkjs 2.1.7 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,61 @@
 # CHANGELOG
 
+## v2.3.0 - 21 de enero de 2026
+
+### Added
+- **QueryBuilder principal**: Implementación completa del QueryBuilder con API fluida para construir consultas SQL complejas de manera segura
+- **Método setAdapter()**: Implementación del método `setAdapter(adapter)` para configurar dinámicamente cualquier adaptador de base de datos
+- **Adaptador MariaDB**: Implementación del adaptador para MariaDB/MySQL con conexión mediante pool de conexiones
+- **Adaptador de Consola**: Adaptador de ejemplo para mostrar consultas SQL por consola, útil para pruebas y desarrollo
+- **Middleware de Integración**: Sistema completo para inyectar QueryBuilder en solicitudes HTTP con soporte para configuración de adaptadores, registro de consultas y reglas de seguridad
+- **Sistema de Hooks**: Integración completa con el sistema de hooks de JERK para eventos del QueryBuilder, auditoría de consultas y aplicación de reglas de seguridad
+- **Arquitectura modular**: Estructura de archivos separados para cada componente del QueryBuilder, con dependencias claras entre módulos
+- **Seguridad mejorada**: Prevención de inyección SQL mediante el uso de parámetros y sistema de validación de consultas
+- **Soporte para múltiples operaciones**: Métodos para SELECT, INSERT, UPDATE, DELETE con condiciones WHERE, JOINs, GROUP BY, ORDER BY, LIMIT, OFFSET y funciones de agregación
+
+### Changed
+- **Actualización de la versión a 2.3.0**: Debido a la implementación significativa del componente QueryBuilder
+- **Exportaciones del framework actualizadas**: Se han añadido las nuevas exportaciones del QueryBuilder en el archivo principal index.js
+- **Documentación actualizada**: Se ha añadido una nueva sección en la documentación principal sobre el uso del QueryBuilder
+
+## v2.2.1 - 20 de enero de 2026
+
+### Changed
+- **Mejora en el método loadModel()**: Se ha actualizado la lógica de búsqueda de modelos para probar múltiples rutas posibles donde podrían estar ubicados los modelos, incluyendo './models/', '../models/', '../../models/', '../../../models/' y rutas sin subdirectorios
+- **Manejo de errores mejorado**: Se ha implementado un sistema que captura los errores de cada intento de carga y solo lanza un error final si no se encuentra el modelo en ninguna ubicación
+- **Soporte para carga perezosa de modelos**: Se ha implementado un sistema de carga perezosa para que los modelos se carguen solo cuando se necesiten, evitando problemas de inicialización temprana
+
+## v2.2.0 - 20 de enero de 2026
+
+### Added
+- **Arquitectura completa de modelos (MVC)**: Se ha implementado la capa de modelos para completar el patrón MVC, incluyendo ModelBase, ModelManager y modelos específicos
+- **Sistema de adaptadores de base de datos**: Se ha creado un sistema flexible de adaptadores que permite conectar con diferentes tipos de bases de datos (MariaDB, MySQL, memoria, etc.)
+- **Nuevo adaptador MariaDB**: Se ha implementado un adaptador específico para conexión a bases de datos MariaDB/MySQL
+- **Modelos específicos**: Se han creado modelos específicos para diferentes entidades con métodos especializados para consultas complejas
+- **Integración con sistema de hooks**: Los modelos participan en el sistema de hooks del framework para extensibilidad
+- **Comunicación bidireccional entre modelos y controladores**: Se ha implementado un sistema para que modelos y controladores se comuniquen entre sí
+- **Soporte para consultas avanzadas**: Los modelos incluyen soporte para paginación, filtros, búsqueda global y operaciones CRUD completas
+- **Validación de datos en modelos**: Se ha implementado un sistema de validación de datos específico para cada modelo
+- **Helper loadModel en ControllerBase**: Se ha añadido el método loadModel() para facilitar la carga de modelos en los controladores
+
+### Changed
+- **Actualización de la versión a 2.2.0**: Debido a la implementación significativa de la arquitectura de modelos
+- **Refactorización de componentes existentes**: Se han actualizado controladores y otros componentes para integrarse con la nueva arquitectura de modelos
+- **Mejora en la estructura interna**: La arquitectura ahora sigue completamente el patrón MVC
+
+## v2.1.8 - 20 de enero de 2026
+
+### Added
+- **Soporte completo para rutas estáticas**: Se ha implementado soporte completo para servir archivos estáticos desde rutas definidas en `routes.json` o mediante el método `addRoute()`
+- **Sistema de hooks para rutas estáticas**: Se han añadido múltiples hooks para rastrear el flujo completo de archivos estáticos
+- **Sistema de logging para hooks**: Se ha implementado un sistema de logging que registra todos los eventos de hooks en un archivo
+- **Soporte para layouts en ViewEngine**: Se ha añadido soporte para layouts con placeholder `{{content}}` en el sistema de vistas
+- **Mejoras en el sistema de enrutamiento**: Se han añadido mejoras para reconocer correctamente rutas estáticas como prefijos
+
+### Changed
+- **Actualización de documentación**: Se ha actualizado la documentación para reflejar las nuevas funcionalidades de rutas estáticas
+- **Optimización del sistema de rutas**: Mejora en la lógica de coincidencia de rutas para soportar rutas estáticas como prefijos
+
 ## v2.1.7 - 19 de enero de 2026
 
 ### Correcciones

package/README.md

@@ -1,4 +1,4 @@
-# JERK Framework v2.1.7
+# JERK Framework v2.3.0
 
 ![JERK Framework Logo](jerk.jpg)
 
@@ -12,6 +12,8 @@ Nuestro Starter Kit en `@standard/server.js` es la forma más rápida de comenza
 - Sistema de controladores preconfigurado
 - 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**
 
 **Cómo comenzar:**
 1. Edita el archivo `routes.json` para definir tus rutas y asociarlas a tus controladores
@@ -49,10 +51,61 @@ class HomeController {
 module.exports = new HomeController();
 ```
 
-3. ¡Tu aplicación estará lista para usar!
+3. ¡Tu aplicación estará listo para usar!
 
 El Starter Kit incluye controladores de ejemplo para que puedas ver cómo funciona el sistema.
 
+## Ejemplo de Rutas Estáticas
+
+Desde la versión 2.1.8, JERK Framework soporta rutas estáticas para servir archivos desde directorios locales:
+
+### En routes.json:
+```json
+[
+  {
+    "path": "/static",
+    "method": "GET",
+    "static": {
+      "dir": "./public",
+      "index": ["index.html", "index.htm"],
+      "cacheControl": "public, max-age=3600"
+    }
+  },
+  {
+    "path": "/assets",
+    "method": "GET",
+    "static": {
+      "dir": "./public",
+      "index": [],
+      "cacheControl": "public, max-age=86400"
+    }
+  }
+]
+```
+
+### Usando addRoute():
+```javascript
+// Ruta estática para servir archivos desde ./public
+server.addRoute({
+  method: 'GET',
+  path: '/static',
+  static: {
+    dir: './public',
+    index: ['index.html'],
+    cacheControl: 'public, max-age=3600'
+  }
+});
+
+// Ruta estática para servir archivos JS, CSS e imágenes
+server.addRoute('GET', '/assets', {
+  static: {
+    dir: './public/assets',
+    index: [],
+    cacheControl: 'public, max-age=86400'
+  }
+});
+```
+
 Visita nuestra página web: https://jerk.page.gd/
 Repositorio oficial: https://gitlab.com/bytedogssyndicate1/jerk/
 
@@ -60,10 +113,10 @@ Repositorio oficial: https://gitlab.com/bytedogssyndicate1/jerk/
 
 - **Arquitectura Modular**: Componentes independientes para mayor flexibilidad
 - **Seguridad Avanzada**: Firewall integrado (WAF) con detección de ataques
-- **Sistema de Hooks**: Similar al sistema de WordPress para extensibilidad
+- **Sistema de Hooks**: Similar al sistema de WordPress para extensibility
 - **Autenticación Flexible**: Soporte para JWT, API Keys, Basic Auth, OAuth2, OpenID Connect
 - **Almacenamiento de Tokens**: Soporte para memoria, JSON, SQLite y MariaDB
-- **Enrutamiento Avanzado**: Soporte para rutas parametrizadas y anidadas
+- **Enrutamiento Avanzado**: Soporte para rutas parametrizadas, anidadas y estáticas
 - **Soporte para Frontend**: Capacidad de servir contenido HTML y otros tipos de contenido
 - **Configuración de Content-Type**: Especificación de headers Content-Type en routes.json
 - **Middlewares Integrados**: CORS, rate limiting, compresión, firewall, etc.
@@ -71,6 +124,11 @@ Repositorio oficial: https://gitlab.com/bytedogssyndicate1/jerk/
 - **Carga de Rutas**: Definición de rutas desde archivos JSON
 - **Sistema de Sesiones**: Gestión completa de sesiones con soporte para autenticación
 - **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
+- **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
 
 ## Instalación
@@ -226,6 +284,148 @@ Las contribuciones son bienvenidas. Por favor, abre un issue o envía un pull re
 
 Apache 2.0
 
+## Arquitectura de Modelos (MVC)
+
+JERK Framework v2.2.0 introduce una arquitectura completa de modelos que completa el patrón MVC. Los modelos permiten encapsular la lógica de negocio y el acceso a datos en componentes reutilizables.
+
+### Ejemplo de Modelo Simple con MariaDB
+
+```javascript
+const { ModelBase, MariaDBAdapter } = require('jerkjs');
+
+// Definir un modelo para usuarios
+class UserModel extends ModelBase {
+  constructor(options = {}) {
+    super({
+      ...options,
+      tableName: options.tableName || 'users'
+    });
+
+    // Definir campos del modelo
+    this.fields = {
+      id: { type: 'integer', primaryKey: true, autoIncrement: true },
+      username: { type: 'string', required: true },
+      email: { type: 'string', required: true },
+      password: { type: 'string', required: true },
+      createdAt: { type: 'datetime', default: 'CURRENT_TIMESTAMP' }
+    };
+  }
+
+  // Método personalizado para encontrar usuario por email
+  async findByEmail(email) {
+    return await this.findOne({ email });
+  }
+
+  // Método personalizado para crear usuario con validación
+  async createUser(userData) {
+    // Validar datos antes de crear
+    const validation = this.validate('create', userData);
+    if (!validation.isValid) {
+      throw new Error(`Validación fallida: ${validation.errors.join(', ')}`);
+    }
+
+    return await this.create(userData);
+  }
+}
+
+// Configurar el adaptador de MariaDB
+const dbConfig = {
+  host: 'localhost',
+  user: 'tu_usuario',
+  password: 'tu_contraseña',
+  database: 'tu_base_de_datos'
+};
+
+const mariaDBAdapter = new MariaDBAdapter(dbConfig);
+
+// Crear instancia del modelo con el adaptador
+const userModel = new UserModel({
+  adapter: mariaDBAdapter,
+  tableName: 'users'
+});
+
+// Uso del modelo
+async function ejemploUsoModelo() {
+  try {
+    // Crear un nuevo usuario
+    const nuevoUsuario = await userModel.createUser({
+      username: 'juan.perez',
+      email: 'juan@example.com',
+      password: 'contraseña_segura'
+    });
+
+    console.log('Usuario creado:', nuevoUsuario);
+
+    // Buscar usuario por email
+    const usuario = await userModel.findByEmail('juan@example.com');
+    console.log('Usuario encontrado:', usuario);
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+```
+
+### Uso de Modelos en Controladores con loadModel
+
+JERK Framework proporciona un helper `loadModel` en el ControllerBase para facilitar la carga y uso de modelos en los controladores:
+
+```javascript
+const ControllerBase = require('jerkjs').ControllerBase;
+
+class UserController extends ControllerBase {
+  constructor() {
+    super();
+
+    // Cargar el modelo de usuario
+    this.userModel = this.loadModel('UserModel', {
+      // Opciones del modelo
+    });
+  }
+
+  async getAllUsers(req, res) {
+    try {
+      // Usar el modelo para obtener usuarios
+      const users = await this.userModel.find({});
+
+      this.json(res, { success: true, data: users });
+    } catch (error) {
+      this.json(res, { success: false, error: error.message }, 500);
+    }
+  }
+
+  async getUserById(req, res) {
+    try {
+      const userId = req.params.id;
+
+      // Usar el modelo para encontrar un usuario específico
+      const user = await this.userModel.findOne({ id: userId });
+
+      if (!user) {
+        this.json(res, { success: false, error: 'Usuario no encontrado' }, 404);
+        return;
+      }
+
+      this.json(res, { success: true, data: user });
+    } catch (error) {
+      this.json(res, { success: false, error: error.message }, 500);
+    }
+  }
+
+  async createUser(req, res) {
+    try {
+      // Usar el modelo para crear un nuevo usuario
+      const newUser = await this.userModel.createUser(req.body);
+
+      this.json(res, { success: true, data: newUser }, 201);
+    } catch (error) {
+      this.json(res, { success: false, error: error.message }, 400);
+    }
+  }
+}
+
+module.exports = new UserController();
+```
+
 ## Documentación del Framework
 
 Para una descripción detallada de la arquitectura y componentes del framework, consulta el archivo [JERK_FRAMEWORK_DOCUMENTATION.md](JERK_FRAMEWORK_DOCUMENTATION.md).

package/README_EN.md

@@ -1,4 +1,4 @@
-# JERK Framework v2.1.4
+# JERK Framework v2.3.0
 
 ![JERK Framework Logo](jerk.jpg)
 

package/README_PT.md

@@ -1,4 +1,4 @@
-# JERK Framework v2.1.4
+# JERK Framework v2.3.0
 
 ![JERK Framework Logo](jerk.jpg)
 

package/docs/ARQUITECTURA_ROUTES.md

@@ -19,13 +19,15 @@ Componente principal que gestiona las rutas y el ciclo de vida de la solicitud H
 - Soporta rutas parametrizadas con conversión a expresiones regulares
 - Mantiene un cache de expresiones regulares para rutas parametrizadas
 - Ejecuta middlewares antes de los handlers de rutas
+- Soporta rutas estáticas para servir archivos desde directorios locales
 
 **Método `addRoute`:**
 - Recibe: método HTTP, path y handler
-- No soporta autenticación por ruta
-- No soporta content-type por ruta
-- No carga controladores desde archivos externos
-- Simplemente registra la ruta en el array
+- Soporta autenticación por ruta
+- Soporta content-type por ruta
+- Soporta rutas estáticas con propiedad `static`
+- Carga controladores desde archivos externos
+- Registra la ruta en el array
 
 ### 2. RouteLoader (lib/loader/routeLoader.js)
 
@@ -37,6 +39,7 @@ Componente encargado de cargar rutas desde archivos JSON.
 - Carga controladores desde archivos externos
 - Aplica autenticación por ruta
 - Aplica content-type por ruta
+- Soporta rutas estáticas
 - Dispara hooks antes y después de cargar rutas
 - Soporta recarga automática de rutas
 
@@ -45,18 +48,21 @@ Componente encargado de cargar rutas desde archivos JSON.
 - Obtiene el handler del controlador
 - Aplica content-type si está especificado
 - Aplica autenticación si está especificada
+- Procesa rutas estáticas si están definidas
 - Integra el handler procesado con el servidor usando `server.addRoute`
 
 ## Funcionalidades Soportadas por routes.json
 
 ### 1. Estructura Básica
 ```json
-{
-  "path": "/ruta/ejemplo",
-  "method": "GET",
-  "controller": "./controllers/EjemploController.js",
-  "handler": "metodoHandler"
-}
+[
+  {
+    "path": "/ruta/ejemplo",
+    "method": "GET",
+    "controller": "./controllers/EjemploController.js",
+    "handler": "metodoHandler"
+  }
+]
 ```
 
 ### 2. Content-Type por Ruta
@@ -85,17 +91,35 @@ Tipos de autenticación soportados:
 ### 4. Rutas Parametrizadas
 Soporta rutas con parámetros como `/usuarios/:id` que se convierten a expresiones regulares.
 
+### 5. Rutas Estáticas
+Soporta rutas para servir archivos estáticos desde directorios locales:
+
+```json
+[
+  {
+    "path": "/static",
+    "method": "GET",
+    "static": {
+      "dir": "./public",
+      "index": ["index.html", "index.htm"],
+      "cacheControl": "public, max-age=3600"
+    }
+  }
+]
+```
+
 ## Comparativa: routes.json vs addRoute()
 
 | Característica | routes.json | addRoute() |
 |---|---|---|
 | Definición de rutas | Masiva (archivo JSON) | Individual |
 | Carga de controladores | Automática desde archivos | Manual (función handler) |
-| Autenticación por ruta | ✅ Soportada | ❌ No soportada |
-| Content-Type por ruta | ✅ Soportado | ❌ No soportado |
-| Opciones de autenticación | ✅ Soportadas | ❌ No soportadas |
+| Autenticación por ruta | ✅ Soportada | ✅ Soportada |
+| Content-Type por ruta | ✅ Soportado | ✅ Soportado |
+| Opciones de autenticación | ✅ Soportadas | ✅ Soportadas |
 | Rutas parametrizadas | ✅ Soportadas | ✅ Soportadas |
-| Integración con hooks | ✅ Soportada | ❌ No soportada |
+| Rutas estáticas | ✅ Soportadas | ✅ Soportadas |
+| Integración con hooks | ✅ Soportada | ✅ Soportada |
 
 ## Flujo de Procesamiento de Rutas
 
@@ -103,38 +127,60 @@ Soporta rutas con parámetros como `/usuarios/:id` que se convierten a expresion
 1. `RouteLoader.loadRoutes()` lee el archivo JSON
 2. Valida la estructura del archivo
 3. Para cada ruta, `loadSingleRoute()`:
-   - Carga el módulo del controlador
-   - Obtiene el handler
+   - Si es ruta estática, llama directamente a `server.addRoute()` con configuración estática
+   - Si es ruta dinámica, carga el módulo del controlador
+   - Obtiene el handler del controlador
    - Aplica content-type si existe
    - Aplica autenticación si existe
    - Llama a `server.addRoute()` con el handler procesado
 4. El servidor procesa las solicitudes normalmente
 
 ### Para addRoute():
-1. Cliente llama directamente `server.addRoute(method, path, handler)`
+1. Cliente llama directamente `server.addRoute(method, path, handler)` o `server.addRoute(configObject)`
 2. La ruta se registra directamente en `this.routes`
-3. El servidor procesa las solicitudes normalmente
-
-## Problemas Identificados
-
-### 1. Incompatibilidad entre ambos sistemas
-- No hay coordinación entre rutas definidas vía `routes.json` y `addRoute()`
-- Ambos sistemas operan de forma independiente
-
-### 2. Diferencia de funcionalidades
-- `routes.json` soporta muchas más características que `addRoute()`
-- `addRoute()` es mucho más básico
+3. Si es una ruta estática (tiene propiedad `static`), se crea un handler especial para servir archivos
+4. El servidor procesa las solicitudes normalmente
 
-## Soluciones Potenciales
+## Rutas Estáticas
 
-### 1. Extender el método addRoute()
-Modificar `addRoute()` para que acepte un objeto de opciones similar al usado en `routes.json`, permitiendo:
-- Especificar content-type
-- Configurar autenticación
-- Definir opciones de autenticación
+### Definición
+Las rutas estáticas permiten servir archivos desde directorios locales. Se definen con la propiedad `static`:
 
-### 2. Crear un método interno común
-Crear un método interno que procese las rutas con todas las funcionalidades y que sea utilizado tanto por `RouteLoader` como por `addRoute()`.
+```json
+{
+  "path": "/assets",
+  "method": "GET",
+  "static": {
+    "dir": "./public/assets",
+    "index": ["index.html"],
+    "cacheControl": "public, max-age=3600"
+  }
+}
+```
 
-### 3. Mantener compatibilidad
-Cualquier cambio debe mantener la compatibilidad con el sistema existente de `routes.json`.
+### Características
+- Sirve cualquier archivo dentro del directorio especificado
+- Detecta automáticamente el tipo MIME
+- Soporta archivos índice para carpetas
+- Permite configurar headers de caché
+- Previene ataques de path traversal
+- Compatible con el sistema de hooks del framework
+
+### Integración con Hooks
+El sistema de rutas estáticas incluye integración con el sistema de hooks:
+
+- `pre_static_file_serve`: Antes de procesar un archivo estático
+- `static_file_served`: Después de servir un archivo estático
+- `static_file_not_found`: Cuando no se encuentra un archivo estático
+- `static_file_access_denied`: Cuando se niega el acceso a un archivo estático
+- `serving_index_file`: Cuando se sirve un archivo índice
+- `static_directory_no_index`: Cuando un directorio no tiene archivo índice
+- `before_reading_static_file`: Antes de leer un archivo estático
+- `static_file_error`: Cuando ocurre un error al servir un archivo estático
+
+## Problemas Resueltos
+
+### 1. Soporte para archivos estáticos
+- Se ha añadido soporte nativo para servir archivos estáticos
+- Ambos sistemas (routes.json y addRoute) soportan rutas estáticas
+- Se mantiene la seguridad y funcionalidad existente

package/{JERK_FRAMEWORK_DOCUMENTATION.md → docs/JERK_FRAMEWORK_DOCUMENTATION.md}

@@ -463,7 +463,32 @@ Finalmente, se agrega el objeto de sesión al objeto de solicitud (`req.session`
 
 ---
 
-## 13. Sistema de Hooks
+## 13. Componente QueryBuilder
+
+El componente QueryBuilder de JERK Framework v2.3.0 proporciona una interfaz fluida para construir consultas SQL complejas de manera segura y eficiente. Este componente permite a los desarrolladores construir consultas SELECT, INSERT, UPDATE y DELETE sin escribir código SQL directamente, reduciendo el riesgo de inyección SQL y mejorando la legibilidad del código.
+
+```mermaid
+flowchart TD
+    START9([INICIO QueryBuilder])
+    START9 --> A9[Instancia QueryBuilder]
+    A9 --> B9[Definir tabla .table()]
+    B9 --> C9[Seleccionar campos .select()]
+    C9 --> D9[Aplicar condiciones .where()]
+    D9 --> E9[Otras operaciones .orderBy(), .limit(), etc.]
+    E9 --> F9[Definir adaptador .setAdapter()]
+    F9 --> G9[Ejecutar consulta .get(), .insert(), .update(), .delete()]
+    G9 --> END9([FIN])
+```
+
+El QueryBuilder comienza con la creación de una instancia del componente, opcionalmente asociada a una tabla específica. Luego se pueden encadenar métodos para construir la consulta paso a paso: seleccionar campos con `.select()`, aplicar condiciones con `.where()`, ordenar resultados con `.orderBy()`, limitar resultados con `.limit()`, entre otros.
+
+Una vez construida la consulta, se debe asociar un adaptador de base de datos usando el método `.setAdapter()` o pasándolo al constructor. Finalmente, se ejecuta la consulta usando métodos como `.get()` para selecciones, `.insert()` para inserciones, `.update()` para actualizaciones o `.delete()` para eliminaciones.
+
+El componente incluye soporte para múltiples adaptadores de base de datos, incluyendo MariaDB/MySQL y un adaptador de consola para fines de desarrollo y pruebas. Además, está completamente integrado con el sistema de hooks del framework, permitiendo interceptar y modificar consultas en diferentes etapas del proceso.
+
+---
+
+## 14. Sistema de Hooks
 
 El sistema de hooks de JERK Framework v2.0 implementa un patrón de extensibilidad que permite a los desarrolladores modificar o extender el comportamiento del framework en puntos específicos de la ejecución. El sistema soporta dos tipos de hooks: acciones y filtros.
 
@@ -499,7 +524,7 @@ El sistema de hooks mantiene un registro de todos los listeners registrados para
 
 ---
 
-## 14. Resumen de Arquitectura
+## 15. Resumen de Arquitectura
 
 La arquitectura de JERK Framework v2.0 está diseñada para proporcionar un equilibrio entre simplicidad y funcionalidad. El framework sigue principios de diseño que facilitan tanto el desarrollo rápido de aplicaciones como la escalabilidad a medida que los requisitos de la aplicación crecen.
 
@@ -520,6 +545,7 @@ El motor de plantillas y el sistema de sesiones proporcionan funcionalidades ese
 - **Middlewares de seguridad**: `lib/middleware/authenticator.js`, `lib/middleware/firewall.js`
 - **Cargador de rutas**: `lib/loader/routeLoader.js`
 - **Componentes MVC**: `lib/mvc/viewEngine.js`, `lib/mvc/controllerBase.js`
+- **Componentes QueryBuilder**: `lib/query/queryBuilder.js`, `lib/query/queryBuilderMiddleware.js`, `lib/query/queryBuilderHooks.js`, `lib/query/MariaDBAdapter.js`, `lib/query/consoleAdapter.js`
 - **Utilidades**: `lib/utils/tokenManager.js`, `lib/utils/logger.js`
 
 ---