jerkjs 2.1.4 → 2.1.6

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # CHANGELOG
 
+## v2.1.6 - 18 de enero de 2026
+
+### Actualizaciones
+
+- **Actualización de la biblioteca Hooked Lib a versión 2.0**: Se ha actualizado la biblioteca de hooks existente (@lib/core/hooks.js) a la versión 2.0, que ahora permite implementar patrones de extensibilidad mediante hooks y filtros, similar a los utilizados en WordPress. Incluye soporte para namespaces (namespace::hookName), prioridades, identificadores de callbacks, operaciones síncronas y asíncronas (doActionAsync, applyFiltersAsync), y validación de entradas.
+
+### Mejoras
+
+- **Sistema de extensibilidad mejorado**: La actualización a Hooked Lib 2.0 proporciona capacidades avanzadas de hooks y filtros con soporte para namespaces, operaciones asíncronas, y gestión flexible de prioridades e identificadores de callbacks.
+
+## v2.1.5 - 17 de enero de 2026
+
+### Nuevas características
+
+- **Implementación completa del sistema MVC**: Se ha completado la implementación del sistema MVC con soporte para controladores que extienden ControllerBase, vistas con procesamiento de variables anidadas en bucles y condiciones, y sistema de layouts. Esta funcionalidad está disponible tanto para aplicaciones que usan `routes.json` como para aquellas que utilizan `addRoute()` directamente.
+
+- **Soporte completo para vistas con variables anidadas**: El ViewEngine ahora soporta completamente el procesamiento de variables anidadas en bucles `{{foreach}}` y estructuras condicionales `{{if}}`, permitiendo construir interfaces complejas con datos dinámicos. Esta funcionalidad es accesible tanto en la arquitectura basada en `routes.json` como en la basada en `addRoute()`.
+
+- **Ejemplo completo de servidor sin routes.json**: Se ha implementado un ejemplo completo (`@standardA/`) que demuestra cómo usar el framework sin el archivo `routes.json`, utilizando `addRoute()` con todas las funcionalidades equivalentes a las disponibles con `routes.json`.
+
+### Mejoras
+
+- **Sistema MVC más robusto**: Se ha mejorado la integración entre controladores, vistas y modelos, permitiendo un desarrollo más estructurado y mantenible en ambas arquitecturas (con y sin `routes.json`).
+- **Procesamiento de variables anidadas**: Se ha mejorado el procesamiento de variables como `{{item.property}}` dentro de bucles `{{foreach}}`, permitiendo el uso completo de estructuras de datos complejas en las vistas, tanto en aplicaciones que usan `routes.json` como en aquellas que utilizan `addRoute()` directamente.
+
+### Correcciones
+
+- **Corrección en el procesamiento de variables anidadas**: Se resolvieron problemas con el procesamiento de variables como `{{item.property}}` dentro de bucles `{{foreach}}`, permitiendo el uso completo de estructuras de datos complejas en las vistas, tanto en la arquitectura con `routes.json` como en la arquitectura sin `routes.json`.
+- **Corrección en el manejo de rutas sin routes.json**: Se resolvió el problema con el sistema de rutas cuando se utiliza `addRoute()` directamente sin el archivo `routes.json`, permitiendo que ambas arquitecturas funcionen correctamente con el sistema MVC y vistas.
+
 ## v2.1.4 - 17 de enero de 2026
 
 ### README

package/README.md

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

package/README_EN.md

@@ -0,0 +1,230 @@
+# JERK Framework v2.1.4
+
+![JERK Framework Logo](jerk.jpg)
+
+**New to JERK? Start your project quickly with our Starter Kit**
+
+Our Starter Kit at `@standard/server.js` is the fastest way to get started with JERK. It comes with all framework functionalities already configured, allowing you to focus on developing your application instead of setting up infrastructure.
+
+**Features of the Starter Kit:**
+- Ready-to-use configuration with all main components
+- Route loading from JSON file (`routes.json`)
+- Preconfigured controller system
+- Essential middlewares already integrated (authentication, CORS, compression, firewall, etc.)
+- Implemented logging and error handling system
+
+**How to get started:**
+1. Edit the `routes.json` file to define your routes and associate them with your controllers
+
+Basic example of `routes.json`:
+```json
+[
+  {
+    "path": "/",
+    "method": "GET",
+    "controller": "HomeController",
+    "handler": "index",
+    "contentType": "text/html"
+  },
+  {
+    "path": "/api/users",
+    "method": "GET",
+    "controller": "UserController",
+    "handler": "getAllUsers",
+    "contentType": "application/json"
+  }
+]
+```
+
+2. Create your controllers according to the defined routes
+
+For example, for the main route "/", create a `HomeController.js` file:
+```javascript
+class HomeController {
+  index(req, res) {
+    res.render('index.html', { data: 'Hello' });
+  }
+}
+
+module.exports = new HomeController();
+```
+
+3. Your application is ready to use!
+
+The Starter Kit includes sample controllers so you can see how the system works.
+
+Visit our website: https://jerk.page.gd/
+Official repository: https://gitlab.com/bytedogssyndicate1/jerk/
+
+## Features
+
+- **Modular Architecture**: Independent components for greater flexibility
+- **Advanced Security**: Built-in firewall (WAF) with attack detection
+- **Hook System**: Similar to WordPress system for extensibility
+- **Flexible Authentication**: Support for JWT, API Keys, Basic Auth, OAuth2, OpenID Connect
+- **Token Storage**: Support for memory, JSON, SQLite and MariaDB
+- **Advanced Routing**: Support for parameterized and nested routes
+- **Frontend Support**: Ability to serve HTML content and other content types
+- **Content-Type Configuration**: Specification of Content-Type headers in routes.json
+- **Integrated Middlewares**: CORS, rate limiting, compression, firewall, etc.
+- **Controller Management**: Dynamic loading of controllers from files
+- **Route Loading**: Definition of routes from JSON files
+- **Session System**: Complete session management with authentication support
+- **MVC Template Engine**: Professional view system with support for filters, helpers and hooks
+- **Extensibility**: Hook and filter system for customization
+
+## Installation
+
+```bash
+npm install jerkjs
+```
+
+## Basic Usage
+
+```javascript
+const { APIServer, Router, Logger } = require('jerkjs');
+
+// Create server instance
+const server = new APIServer({
+  port: 3000,
+  host: 'localhost'
+});
+
+// Create logger instance
+const logger = new Logger({ level: 'info' });
+
+// Define routes
+server.addRoute('GET', '/', (req, res) => {
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({ message: 'Hello World!' }));
+});
+
+// Start the server
+server.start();
+```
+
+## Main Components
+
+### APIServer
+Basic HTTP/HTTPS server with support for parameterized routes, middlewares and advanced configuration.
+
+### Router
+Advanced routing system with support for nested routes and prefixes.
+
+### Authenticator
+Authentication middleware with support for multiple methods (JWT, API Keys, Basic Auth, OAuth2, OpenID Connect).
+
+### SecurityEnhancedServer
+Server with integrated advanced security features (WAF).
+
+### RouteLoader
+Loading of routes from JSON files with support for authentication, controllers and content-type specification.
+
+### TokenManager
+JWT token management with different storage types (memory, JSON, SQLite, MariaDB).
+
+### Firewall
+Firewall middleware with attack pattern detection and white/black lists.
+
+### Hooks System
+Hook and filter system similar to WordPress for extensibility.
+
+### SessionManager
+Complete session management system with session-based authentication support.
+
+### ViewEngine
+Professional template engine with support for filters, helpers, conditions, loops and hooks.
+
+### ControllerBase
+Base controller that facilitates the development of MVC controllers with view support.
+
+## Security
+
+The framework includes multiple layers of security:
+
+- **Web Application Firewall (WAF)**: Detection of SQL injection, XSS, path traversal, etc.
+- **Rate Limiting**: Request limitation by IP or user
+- **Firewall**: Automatic blocking by failed attempts
+- **White/Black Lists**: Access control by IP
+- **Security Auditing**: Event logging
+- **Robust Authentication**: Support for multiple authentication methods
+
+## Hook System
+
+The framework includes a hook and filter system similar to WordPress:
+
+```javascript
+const { hooks } = require('jerkjs');
+
+// Register an action
+hooks.addAction('firewall_request_blocked', (rule, clientIP, req, res) => {
+  console.log(`Blocked request: ${rule.name} for IP: ${clientIP}`);
+});
+
+// Register a filter
+hooks.addFilter('session_create_data', (userData, req) => {
+  return {
+    ...userData,
+    ipAddress: req.headers['x-forwarded-for'] || req.connection.remoteAddress,
+    createdAt: new Date().toISOString()
+  };
+});
+```
+
+## MVC Template Engine
+
+The framework includes a professional template engine with support for:
+
+- Variables: `{{variable}}`
+- Conditions: `{{if variable}}content{{endif}}`
+- Loops: `{{foreach:array}}content{{endforeach}}`
+- Includes: `{{include:header}}`
+- Filters: `{{variable|upper}}`
+- Custom helpers
+
+## Session Management
+
+The framework includes a complete session management system:
+
+```javascript
+const { SessionManager } = require('jerkjs');
+
+const sessionManager = new SessionManager({
+  secret: 'your-session-secret',
+  timeout: 3600000 // 1 hour
+});
+
+// Use as middleware
+server.use(sessionManager.middleware());
+```
+
+## Examples
+
+The project includes several complete examples:
+
+- **v2_json_auth**: JWT authentication with tokens stored in JSON
+- **v2_mariadb_auth**: JWT authentication with tokens stored in MariaDB
+- **v2_sqlite_auth**: JWT authentication with tokens stored in SQLite
+- **public**: Sample public API with CORS and rate limiting
+- **frontend**: Server example that combines API and frontend with different content-types
+- **hooks**: Advanced example of hook system usage with logging and request tracking
+
+To see the complete examples, visit the `v2examplle/` and `examples/` directories.
+
+## Documentation
+
+In addition to the documentation in the README, the project includes additional documentation:
+
+- **Quick start guide**: `docs/guia_inicio_rapido_jerkjs.md` - A complete guide to getting started quickly with JERKJS, including file formats, controller structure, template engine and hook system.
+
+## Contributions
+
+Contributions are welcome. Please open an issue or submit a pull request on GitLab.
+
+## License
+
+Apache 2.0
+
+## Framework Documentation
+
+For a detailed description of the framework architecture and components, see the [JERK_FRAMEWORK_DOCUMENTATION.md](JERK_FRAMEWORK_DOCUMENTATION.md) file.

package/README_PT.md

@@ -0,0 +1,230 @@
+# JERK Framework v2.1.4
+
+![JERK Framework Logo](jerk.jpg)
+
+**Novo no JERK? Comece seu projeto rapidamente com nosso Kit Inicial**
+
+Nosso Kit Inicial em `@standard/server.js` é a forma mais rápida de começar com o JERK. Ele vem com todas as funcionalidades do framework já configuradas, permitindo que você se concentre em desenvolver sua aplicação em vez de configurar infraestrutura.
+
+**Recursos do Kit Inicial:**
+- Configuração pronta para uso com todos os componentes principais
+- Carregamento de rotas a partir de arquivo JSON (`routes.json`)
+- Sistema de controladores pré-configurado
+- Middlewares essenciais já integrados (autenticação, CORS, compressão, firewall, etc.)
+- Sistema de logging e tratamento de erros implementado
+
+**Como começar:**
+1. Edite o arquivo `routes.json` para definir suas rotas e associá-las aos seus controladores
+
+Exemplo básico de `routes.json`:
+```json
+[
+  {
+    "path": "/",
+    "method": "GET",
+    "controller": "HomeController",
+    "handler": "index",
+    "contentType": "text/html"
+  },
+  {
+    "path": "/api/users",
+    "method": "GET",
+    "controller": "UserController",
+    "handler": "getAllUsers",
+    "contentType": "application/json"
+  }
+]
+```
+
+2. Crie seus controladores de acordo com as rotas definidas
+
+Por exemplo, para a rota principal "/", crie um arquivo `HomeController.js`:
+```javascript
+class HomeController {
+  index(req, res) {
+    res.render('index.html', { data: 'Olá' });
+  }
+}
+
+module.exports = new HomeController();
+```
+
+3. Sua aplicação está pronta para usar!
+
+O Kit Inicial inclui controladores de exemplo para que você possa ver como o sistema funciona.
+
+Visite nosso site: https://jerk.page.gd/
+Repositório oficial: https://gitlab.com/bytedogssyndicate1/jerk/
+
+## Recursos
+
+- **Arquitetura Modular**: Componentes independentes para maior flexibilidade
+- **Segurança Avançada**: Firewall integrado (WAF) com detecção de ataques
+- **Sistema de Hooks**: Semelhante ao sistema do WordPress para extensibilidade
+- **Autenticação Flexível**: Suporte para JWT, API Keys, Basic Auth, OAuth2, OpenID Connect
+- **Armazenamento de Tokens**: Suporte para memória, JSON, SQLite e MariaDB
+- **Roteamento Avançado**: Suporte para rotas parametrizadas e aninhadas
+- **Suporte para Frontend**: Capacidade de servir conteúdo HTML e outros tipos de conteúdo
+- **Configuração de Content-Type**: Especificação de cabeçalhos Content-Type em routes.json
+- **Middlewares Integrados**: CORS, limitação de taxa, compressão, firewall, etc.
+- **Gerenciamento de Controladores**: Carregamento dinâmico de controladores a partir de arquivos
+- **Carregamento de Rotas**: Definição de rotas a partir de arquivos JSON
+- **Sistema de Sessões**: Gerenciamento completo de sessões com suporte para autenticação
+- **Mecanismo de Templates MVC**: Sistema profissional de visualização com suporte para filtros, helpers e hooks
+- **Extensibilidade**: Sistema de hooks e filtros para personalização
+
+## Instalação
+
+```bash
+npm install jerkjs
+```
+
+## Uso Básico
+
+```javascript
+const { APIServer, Router, Logger } = require('jerkjs');
+
+// Criar instância do servidor
+const server = new APIServer({
+  port: 3000,
+  host: 'localhost'
+});
+
+// Criar instância do logger
+const logger = new Logger({ level: 'info' });
+
+// Definir rotas
+server.addRoute('GET', '/', (req, res) => {
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({ message: 'Olá Mundo!' }));
+});
+
+// Iniciar o servidor
+server.start();
+```
+
+## Componentes Principais
+
+### APIServer
+Servidor HTTP/HTTPS básico com suporte para rotas parametrizadas, middlewares e configuração avançada.
+
+### Router
+Sistema de roteamento avançado com suporte para rotas aninhadas e prefixos.
+
+### Authenticator
+Middleware de autenticação com suporte para múltiplos métodos (JWT, API Keys, Basic Auth, OAuth2, OpenID Connect).
+
+### SecurityEnhancedServer
+Servidor com recursos de segurança avançada (WAF) integrados.
+
+### RouteLoader
+Carregamento de rotas a partir de arquivos JSON com suporte para autenticação, controladores e especificação de tipo de conteúdo.
+
+### TokenManager
+Gerenciamento de tokens JWT com diferentes tipos de armazenamento (memória, JSON, SQLite, MariaDB).
+
+### Firewall
+Middleware de firewall com detecção de padrões de ataque e listas brancas/negras.
+
+### Sistema de Hooks
+Sistema de hooks e filtros semelhante ao WordPress para extensibilidade.
+
+### SessionManager
+Sistema completo de gerenciamento de sessões com suporte para autenticação baseada em sessões.
+
+### ViewEngine
+Mecanismo de templates profissional com suporte para filtros, helpers, condições, loops e hooks.
+
+### ControllerBase
+Controlador base que facilita o desenvolvimento de controladores MVC com suporte para visualizações.
+
+## Segurança
+
+O framework inclui múltiplas camadas de segurança:
+
+- **Web Application Firewall (WAF)**: Detecção de injeção SQL, XSS, travessia de caminho, etc.
+- **Limitação de Taxa**: Limitação de requisições por IP ou usuário
+- **Firewall**: Bloqueio automático por tentativas falhas
+- **Listas Brancas/Negras**: Controle de acesso por IP
+- **Auditoria de Segurança**: Registro de eventos de segurança
+- **Autenticação Robusta**: Suporte para múltiplos métodos de autenticação
+
+## Sistema de Hooks
+
+O framework inclui um sistema de hooks e filtros semelhante ao WordPress:
+
+```javascript
+const { hooks } = require('jerkjs');
+
+// Registrar uma ação
+hooks.addAction('firewall_request_blocked', (rule, clientIP, req, res) => {
+  console.log(`Solicitação bloqueada: ${rule.name} para IP: ${clientIP}`);
+});
+
+// Registrar um filtro
+hooks.addFilter('session_create_data', (userData, req) => {
+  return {
+    ...userData,
+    ipAddress: req.headers['x-forwarded-for'] || req.connection.remoteAddress,
+    createdAt: new Date().toISOString()
+  };
+});
+```
+
+## Mecanismo de Templates MVC
+
+O framework inclui um mecanismo de templates profissional com suporte para:
+
+- Variáveis: `{{variable}}`
+- Condições: `{{if variable}}conteúdo{{endif}}`
+- Loops: `{{foreach:array}}conteúdo{{endforeach}}`
+- Inclusões: `{{include:header}}`
+- Filtros: `{{variable|upper}}`
+- Helpers personalizados
+
+## Gerenciamento de Sessões
+
+O framework inclui um sistema completo de gerenciamento de sessões:
+
+```javascript
+const { SessionManager } = require('jerkjs');
+
+const sessionManager = new SessionManager({
+  secret: 'your-session-secret',
+  timeout: 3600000 // 1 hora
+});
+
+// Usar como middleware
+server.use(sessionManager.middleware());
+```
+
+## Exemplos
+
+O projeto inclui vários exemplos completos:
+
+- **v2_json_auth**: Autenticação JWT com tokens armazenados em JSON
+- **v2_mariadb_auth**: Autenticação JWT com tokens armazenados em MariaDB
+- **v2_sqlite_auth**: Autenticação JWT com tokens armazenados em SQLite
+- **public**: API pública de exemplo com CORS e limitação de taxa
+- **frontend**: Exemplo de servidor que combina API e frontend com diferentes tipos de conteúdo
+- **hooks**: Exemplo avançado de uso do sistema de hooks com logging e rastreamento de solicitações
+
+Para ver os exemplos completos, visite os diretórios `v2examplle/` e `examples/`.
+
+## Documentação
+
+Além da documentação no README, o projeto inclui documentação adicional:
+
+- **Guia de início rápido**: `docs/guia_inicio_rapido_jerkjs.md` - Um guia completo para começar rapidamente com o JERKJS, incluindo formatos de arquivos, estrutura de controladores, mecanismo de templates e sistema de hooks.
+
+## Contribuições
+
+As contribuições são bem-vindas. Por favor, abra uma issue ou envie um pull request no GitLab.
+
+## Licença
+
+Apache 2.0
+
+## Documentação do Framework
+
+Para uma descrição detalhada da arquitetura e componentes do framework, consulte o arquivo [JERK_FRAMEWORK_DOCUMENTATION.md](JERK_FRAMEWORK_DOCUMENTATION.md).

package/docs/ARQUITECTURA_ROUTES.md

@@ -0,0 +1,140 @@
+# Arquitectura del Sistema de Rutas en JERK Framework
+
+## Descripción General
+
+El sistema de rutas en JERK Framework permite definir endpoints de API mediante dos métodos principales:
+1. Archivo JSON (`routes.json`) - Carga masiva de rutas
+2. Método `addRoute()` - Definición individual de rutas
+
+## Componentes Principales
+
+### 1. APIServer (lib/core/server.js)
+
+Componente principal que gestiona las rutas y el ciclo de vida de la solicitud HTTP.
+
+**Características:**
+- Almacena rutas en el array `this.routes`
+- Implementa el método `addRoute(method, path, handler)` para definir rutas individuales
+- Maneja el enrutamiento en `findRoute(method, pathname)`
+- 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
+
+**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
+
+### 2. RouteLoader (lib/loader/routeLoader.js)
+
+Componente encargado de cargar rutas desde archivos JSON.
+
+**Características:**
+- Lee y parsea archivos JSON de rutas
+- Valida la estructura del archivo de rutas
+- Carga controladores desde archivos externos
+- Aplica autenticación por ruta
+- Aplica content-type por ruta
+- Dispara hooks antes y después de cargar rutas
+- Soporta recarga automática de rutas
+
+**Método `loadSingleRoute`:**
+- Carga el módulo del controlador
+- Obtiene el handler del controlador
+- Aplica content-type si está especificado
+- Aplica autenticación si está especificada
+- 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"
+}
+```
+
+### 2. Content-Type por Ruta
+```json
+{
+  "contentType": "application/json"
+}
+```
+
+### 3. Autenticación por Ruta
+```json
+{
+  "auth": "jwt",
+  "authOptions": {
+    "jwtSecret": "secreto-ejemplo"
+  }
+}
+```
+
+Tipos de autenticación soportados:
+- `jwt` - Autenticación JWT
+- `apiKey` - Autenticación por API Key
+- `session` - Autenticación por sesión
+- Otros tipos registrados en el authenticator
+
+### 4. Rutas Parametrizadas
+Soporta rutas con parámetros como `/usuarios/:id` que se convierten a expresiones regulares.
+
+## 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 |
+| Rutas parametrizadas | ✅ Soportadas | ✅ Soportadas |
+| Integración con hooks | ✅ Soportada | ❌ No soportada |
+
+## Flujo de Procesamiento de Rutas
+
+### Para routes.json:
+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
+   - 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)`
+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
+
+## Soluciones Potenciales
+
+### 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
+
+### 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()`.
+
+### 3. Mantener compatibilidad
+Cualquier cambio debe mantener la compatibilidad con el sistema existente de `routes.json`.