jerkjs 2.5.8 → 2.6.1

package/docs/CACHE_SYSTEM_MAP.md

@@ -1,206 +0,0 @@
-# Mapa de Procesos de Caché del Framework JERK
-
-## Introducción
-
-Este documento describe los diferentes sistemas de caché implementados en el framework JERK y cómo se integran en los flujos del sistema.
-
-## Sistemas de Caché
-
-### 1. Caché de Expresiones Regulares para Rutas (RouteMatcher)
-
-**Ubicación**: `lib/router/RouteMatcher.js`
-**Tipo**: Mapa de caché (Map)
-**Propósito**: Almacenar expresiones regulares compiladas para rutas parametrizadas
-**Clave**: Ruta con parámetros (ej. `/users/:id`)
-**Valor**: Expresión regular compilada
-**Flujo de proceso**:
-1. Al procesar una ruta parametrizada, se convierte a expresión regular
-2. Antes de compilar, se verifica si ya existe en el cache
-3. Si existe, se devuelve la expresión regular cacheada
-4. Si no existe, se compila, se almacena en cache y se devuelve
-
-**Beneficios**:
-- Evita compilación repetida de expresiones regulares
-- Mejora el rendimiento de coincidencia de rutas parametrizadas
-- Reduce el uso de CPU en operaciones repetidas
-
-### 2. Caché de Vistas (ViewEngine)
-
-**Ubicación**: `lib/mvc/viewEngine.js`
-**Tipo**: Mapa de caché (Map)
-**Propósito**: Almacenar contenido de vistas ya procesadas (sin variables)
-**Clave**: Ruta completa del archivo de vista
-**Valor**: Contenido de la vista procesado (condiciones, bucles, etc. resueltos)
-**Flujo de proceso**:
-1. Al solicitar una vista, se verifica si está en cache
-2. Si está en cache, se procesa con las variables y se devuelve
-3. Si no está en cache, se lee el archivo, se procesa (condiciones, bucles, etc.)
-4. Si el cache está habilitado, se almacena la vista procesada (sin variables)
-5. Se procesan las variables y se devuelve el resultado
-
-**Beneficios**:
-- Evita lectura repetida de archivos de vistas
-- Evita procesamiento repetido de condiciones y bucles
-- Mejora el rendimiento de renderizado de vistas
-
-### 3. Caché de Controladores (ControllerLoader)
-
-**Ubicación**: `lib/loader/controllerLoader.js`
-**Tipo**: Sistema de caché de módulos de Node.js
-**Propósito**: Evitar recarga repetida de módulos de controladores
-**Clave**: Ruta del archivo del controlador
-**Valor**: Instancia del módulo del controlador
-**Flujo de proceso**:
-1. Al cargar un controlador, se verifica si ya está en el cache de require
-2. Si no está en cache, se carga y se mantiene en require.cache
-3. En subsiguientes solicitudes, se devuelve la instancia cacheada
-
-**Beneficios**:
-- Evita recarga repetida de módulos
-- Mejora el rendimiento de carga de controladores
-- Reduce el uso de memoria
-
-### 4. Índices de Rutas (RouteMatcher)
-
-**Ubicación**: `lib/router/RouteMatcher.js`
-**Tipo**: Mapas de índices y estructuras de datos
-**Propósito**: Optimizar la búsqueda de rutas mediante pre-filtrado
-**Componentes**:
-- `exactRoutes`: Mapa de rutas exactas por método y path
-- `routeBuckets`: Estructura jerárquica por método, número de segmentos y primer segmento
-- `indexesValid`: Bandera para validar si los índices están actualizados
-
-**Flujo de proceso**:
-1. Al registrar rutas, se actualizan los índices
-2. Al buscar una ruta, se usan los índices para pre-filtrar candidatos
-3. Se buscan coincidencias exactas primero (más rápido)
-4. Se buscan rutas parametrizadas solo entre candidatos filtrados
-5. Se buscan rutas estáticas por prefijo entre candidatos filtrados
-
-**Beneficios**:
-- Reduce drásticamente el número de rutas a evaluar
-- Mejora el rendimiento de coincidencia de rutas
-- Escala mejor con un gran número de rutas
-
-## Flujos de Integración de Caché
-
-### Flujo de Procesamiento de Solicitudes
-
-```
-Solicitud HTTP
-    ↓
-Middleware de seguridad
-    ↓
-Verificación de índices de rutas (RouteMatcher)
-    ↓
-→ Búsqueda por ruta exacta (más rápida)
-    ↓
-→ Pre-filtrado por número de segmentos y primer segmento
-    ↓
-→ Búsqueda en rutas candidatas
-    ↓
-→ Coincidencia con expresiones regulares (usando cache)
-    ↓
-Ejecución del handler de la ruta
-    ↓
-Renderizado de vista (usando cache de vistas)
-    ↓
-Respuesta HTTP
-```
-
-### Flujo de Caché de Expresiones Regulares
-
-```
-Solicitud de coincidencia de ruta parametrizada
-    ↓
-→ ¿Está la expresión regular en cache?
-    ↓
-┌─────────────┬─────────────┐
-│     SÍ      │     NO      │
-│             │             │
-│ Devolver    │ Compilar    │
-│ regex       │ expresión   │
-│ cacheada    │ regular     │
-│             │             │
-└─────────────┴─────────────┘
-    ↓
-Almacenar en cache
-    ↓
-Usar para coincidencia
-```
-
-### Flujo de Caché de Vistas
-
-```
-Solicitud de renderizado de vista
-    ↓
-→ ¿Está la vista en cache?
-    ↓
-┌─────────────┬─────────────┐
-│     SÍ      │     NO      │
-│             │             │
-│ Procesar    │ Leer archivo│
-│ con vars    │ de vista    │
-│             │             │
-│ Devolver    │ Procesar    │
-│ resultado   │ condiciónes,│
-│             │ bucles, etc.│
-│             │             │
-│             │ → ¿Cache    │
-│             │   habilitado?│
-│             │      ↓      │
-│             │   ┌─────────┼─┐
-│             │   │   SÍ    │ │
-│             │   │         │ │
-│             │   │ Almacenar││
-│             │   │ vista en ││
-│             │   │ cache    ││
-│             │   └─────────┼─┘
-│             │             │
-└─────────────┴─────────────┘
-    ↓
-Devolver HTML renderizado
-```
-
-## Estrategias de Invalidación de Caché
-
-### Caché de Expresiones Regulares
-- No requiere invalidación frecuente
-- Se actualiza automáticamente al cambiar las rutas
-
-### Caché de Vistas
-- Se puede limpiar manualmente con `viewEngine.clearCache()`
-- No se invalida automáticamente (diseñado para vistas estáticas)
-
-### Caché de Controladores
-- Se mantiene durante todo el ciclo de vida del proceso
-- Se puede limpiar manualmente eliminando del `require.cache`
-
-### Índices de Rutas
-- Se actualizan automáticamente al registrar nuevas rutas
-- Se invalidan si cambia el número total de rutas
-
-## Beneficios del Sistema de Caché
-
-1. **Mejora de Rendimiento**: Reducción significativa de operaciones repetidas
-2. **Eficiencia de CPU**: Menos compilación de expresiones regulares y procesamiento de vistas
-3. **Eficiencia de I/O**: Menos lecturas de disco para archivos de vistas
-4. **Escalabilidad**: Mejor manejo de alto volumen de solicitudes
-5. **Optimización de Memoria**: Reutilización de estructuras de datos ya procesadas
-
-## Consideraciones de Seguridad
-
-- Las cachés no almacenan datos sensibles de usuarios
-- Las expresiones regulares cacheadas no contienen información de entrada del usuario
-- Las vistas cacheadas no contienen datos de sesión o variables de usuario
-- El sistema de caché no expone información interna del sistema
-
-## Conclusión
-
-El framework JERK implementa múltiples niveles de caché para optimizar el rendimiento:
-- Caché de expresiones regulares para rutas parametrizadas
-- Caché de vistas procesadas
-- Índices optimizados para búsqueda de rutas
-- Caché de módulos de controladores
-
-Estos sistemas de caché trabajan juntos para proporcionar un rendimiento óptimo al minimizar operaciones repetidas y maximizar la eficiencia del procesamiento de solicitudes.