jerkjs 2.5.4 → 2.5.8

package/lib/admin/modules/STATS_MODULE_README.md

@@ -0,0 +1,98 @@
+# Módulo de Estadísticas para la Extensión de Administración de JERK Framework
+
+## Descripción
+
+El módulo de estadísticas es una extensión de la extensión de administración de JERK Framework que permite monitorear y visualizar métricas importantes del servidor en tiempo real.
+
+## Características
+
+- Conteo de solicitudes procesadas y respuestas enviadas
+- Medición del tráfico de entrada y salida en kilobytes
+- Registro de accesos a rutas y endpoints
+- Identificación de endpoints y rutas más accedidas
+- Sistema de estadísticas global para acceso directo y confiable
+
+## Comandos Disponibles
+
+- `stats` o `statistics`: Muestra estadísticas generales del servidor
+- `requests`: Muestra estadísticas específicas de solicitudes
+- `endpoints`: Muestra estadísticas de endpoints y rutas más accedidas
+
+## Métricas Monitorizadas
+
+### Estadísticas Generales
+- Solicitudes procesadas totales
+- Cantidad de datos recibidos (en KB)
+- Respuestas enviadas totales
+- Cantidad de datos enviados (en KB)
+- Número de rutas registradas
+- Número de rutas activas
+
+### Estadísticas de Solicitudes
+- Total de solicitudes procesadas
+- Total de bytes recibidos
+- Accesos a rutas (Input/Output)
+
+### Estadísticas de Endpoints
+- Top 10 endpoints más accedidos
+- Top 10 rutas más accedidas
+
+## Sistema de Almacenamiento de Estadísticas
+
+A diferencia de enfoques basados en hooks, este módulo utiliza un sistema de almacenamiento global de estadísticas (`globalStats`) que se actualiza directamente en el servidor cuando ocurren eventos, garantizando:
+
+- Acceso directo y confiable a las métricas
+- Actualización en tiempo real sin dependencia de hooks
+- Persistencia de datos entre solicitudes
+- Mayor rendimiento y menor latencia
+
+### Componentes del Sistema de Estadísticas
+
+- `globalStats.requestsProcessed`: Contador de solicitudes procesadas
+- `globalStats.responsesSent`: Contador de respuestas enviadas
+- `globalStats.requestBytes`: Total de bytes recibidos
+- `globalStats.responseBytes`: Total de bytes enviados
+- `globalStats.routeAccesses`: Mapa de accesos a rutas
+- `globalStats.endpointHits`: Mapa de hits a endpoints
+
+### Actualización de Estadísticas en el Servidor
+
+Las estadísticas se actualizan directamente en el servidor en los siguientes puntos:
+
+- Al procesar el cuerpo de la solicitud: actualiza `requestBytes`
+- Al enviar la respuesta: actualiza `responseBytes`
+- Al procesar una ruta: actualiza `requestsProcessed`, `responsesSent`, `routeAccesses`, `endpointHits`
+
+## Instalación
+
+El módulo se carga automáticamente cuando se inicializa la extensión de administración, ya que está ubicado en el directorio `modules` de la extensión.
+
+## Uso
+
+1. Inicialice la extensión de administración en su servidor:
+
+```javascript
+const server = new APIServer({ port: 3000 });
+server.initializeAdminExtension({
+  port: 9999,
+  host: '127.0.0.1'
+});
+```
+
+2. Conéctese al servidor de administración:
+
+```bash
+telnet localhost 9999
+```
+
+3. Use cualquiera de los comandos disponibles:
+
+```
+stats
+requests
+endpoints
+```
+
+## Contribución
+
+Las contribuciones son bienvenidas. Si desea mejorar este módulo, por favor cree un fork del repositorio y envíe un pull request con sus cambios.

package/lib/admin/modules/StatsModule.js

@@ -0,0 +1,140 @@
+/**
+ * Módulo de Estadísticas para la Extensión de Administración de JERK Framework
+ * Módulo personalizado para mostrar estadísticas del servidor
+ */
+
+class StatsModule {
+  /**
+   * Constructor del módulo de estadísticas
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.name = 'Statistics Module';
+    this.description = 'Módulo para mostrar estadísticas del servidor';
+    this.commands = ['stats', 'statistics', 'requests', 'endpoints'];
+    
+    // Cargar el objeto global de estadísticas
+    this.globalStats = require('../../utils/globalStats').globalStats;
+  }
+
+  /**
+   * Manejador para los comandos del módulo de estadísticas
+   * @param {string} command - Comando a ejecutar
+   * @param {Object} socket - Socket de la conexión
+   */
+  handleCommand(command, socket) {
+    switch (command) {
+      case 'stats':
+      case 'statistics':
+        this.showGeneralStats(socket);
+        break;
+      case 'requests':
+        this.showRequestStats(socket);
+        break;
+      case 'endpoints':
+        this.showEndpointStats(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de estadísticas: ${command}\n`);
+        socket.write(`Comandos disponibles: stats, statistics, requests, endpoints\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Muestra estadísticas generales
+   * @param {Object} socket - Socket de la conexión
+   */
+  showGeneralStats(socket) {
+    const formattedRequestBytes = this.formatBytes(this.globalStats.requestBytes);
+    const formattedResponseBytes = this.formatBytes(this.globalStats.responseBytes);
+
+    socket.write('\n=== Estadísticas Generales ===\n');
+    socket.write(`Solicitudes procesadas: ${this.globalStats.requestsProcessed}\n`);
+    socket.write(`Solicitudes procesadas (KB): ${formattedRequestBytes}\n`);
+    socket.write(`Respuestas enviadas: ${this.globalStats.responsesSent}\n`);
+    socket.write(`Respuestas enviadas (KB): ${formattedResponseBytes}\n`);
+    socket.write(`Rutas registradas: ${this.adminExtension.registeredRoutes.length}\n`);
+    socket.write(`Rutas activas: ${this.adminExtension.activeRoutes.size}\n\n`);
+    socket.write(`> `);
+  }
+
+  /**
+   * Muestra estadísticas de solicitudes
+   * @param {Object} socket - Socket de la conexión
+   */
+  showRequestStats(socket) {
+    socket.write('\n=== Estadísticas de Solicitudes ===\n');
+    socket.write(`Total de solicitudes procesadas: ${this.globalStats.requestsProcessed}\n`);
+    socket.write(`Total de bytes recibidos: ${this.formatBytes(this.globalStats.requestBytes)}\n`);
+
+    // Mostrar accesos a rutas
+    if (this.globalStats.routeAccesses.size > 0) {
+      socket.write('\nAccesos a rutas (Input/Output):\n');
+      for (const [route, count] of this.globalStats.routeAccesses) {
+        socket.write(`  ${route}: ${count} accesos\n`);
+      }
+    }
+
+    socket.write('\n> ');
+  }
+
+  /**
+   * Muestra estadísticas de endpoints
+   * @param {Object} socket - Socket de la conexión
+   */
+  showEndpointStats(socket) {
+    socket.write('\n=== Estadísticas de Endpoints y Rutas ===\n');
+
+    // Mostrar endpoints más accedidos
+    if (this.globalStats.endpointHits.size > 0) {
+      socket.write('Endpoints más accedidos:\n');
+
+      // Convertir el mapa a array y ordenar por número de hits
+      const sortedEndpoints = Array.from(this.globalStats.endpointHits.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10); // Mostrar top 10
+
+      for (const [endpoint, hits] of sortedEndpoints) {
+        socket.write(`  ${endpoint}: ${hits} hits\n`);
+      }
+    } else {
+      socket.write('No hay datos de endpoints accedidos.\n');
+    }
+
+    // Mostrar rutas más accedidas
+    if (this.globalStats.routeAccesses.size > 0) {
+      socket.write('\nRutas más accedidas:\n');
+
+      // Convertir el mapa a array y ordenar por número de accesos
+      const sortedRoutes = Array.from(this.globalStats.routeAccesses.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10); // Mostrar top 10
+
+      for (const [route, accesses] of sortedRoutes) {
+        socket.write(`  ${route}: ${accesses} accesos\n`);
+      }
+    } else {
+      socket.write('\nNo hay datos de rutas accedidas.\n');
+    }
+
+    socket.write('\n> ');
+  }
+
+  /**
+   * Formatea bytes a una unidad legible
+   * @param {number} bytes - Cantidad en bytes
+   * @returns {string} - Cantidad formateada con unidad
+   */
+  formatBytes(bytes) {
+    // Manejar valores nulos o indefinidos
+    if (bytes == null || isNaN(bytes) || bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+  }
+}
+
+module.exports = StatsModule;

package/lib/admin/modules/SystemModule.js

@@ -0,0 +1,140 @@
+/**
+ * Módulo de Sistema para la Extensión de Administración de JERK Framework
+ * Módulo personalizado para mostrar información del sistema
+ */
+
+class SystemModule {
+  /**
+   * Constructor del módulo de sistema
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.name = 'System Info Module';
+    this.description = 'Módulo para mostrar información del sistema';
+    this.commands = ['sysinfo', 'system', 'resources'];
+  }
+
+  /**
+   * Manejador para los comandos del módulo de sistema
+   * @param {string} command - Comando a ejecutar
+   * @param {Object} socket - Socket de la conexión
+   */
+  handleCommand(command, socket) {
+    switch (command) {
+      case 'sysinfo':
+      case 'system':
+      case 'resources':
+        this.showSystemInfo(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de sistema: ${command}\n`);
+        socket.write(`Comandos disponibles: sysinfo, system, resources\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Muestra información del sistema en formato de tabla con color verde
+   * @param {Object} socket - Socket de la conexión
+   */
+  showSystemInfo(socket) {
+    const os = require('os');
+    const memUsage = process.memoryUsage();
+    const cpuInfo = os.cpus();
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const usedMem = totalMem - freeMem;
+    const uptime = process.uptime();
+    
+    // Obtener información del proceso
+    const pid = process.pid;
+    const ppid = process.ppid;
+    const execPath = process.execPath;
+    const version = process.version;
+    
+    // Calcular uso de CPU (aproximado)
+    let totalIdle = 0, totalTick = 0;
+    for (const cpu of cpuInfo) {
+      for (const type in cpu.times) {
+        totalTick += cpu.times[type];
+      }
+      totalIdle += cpu.times.idle;
+    }
+    const avgTick = totalTick / cpuInfo.length;
+    const avgIdle = totalIdle / cpuInfo.length;
+    const cpuUsage = Math.round((1 - avgIdle / avgTick) * 10000) / 100;
+
+    // Formatear la información en una tabla
+    const table = `
+\x1b[32m
+╔════════════════════════════════════════════════════════════════╗
+║                        INFORMACIÓN DEL SISTEMA                 ║
+╠════════════════════════════════════════════════════════════════╣
+║ Recursos del Sistema                                           ║
+╠────────────────────────────────────────────────────────────────╣
+║ Memoria Total:     ${this.padRight(this.formatBytes(totalMem), 15)} ║ Memoria Libre:    ${this.padRight(this.formatBytes(freeMem), 15)} ║
+║ Memoria Usada:     ${this.padRight(this.formatBytes(usedMem), 15)} ║ Uso de CPU:       ${this.padRight(cpuUsage + '%', 15)} ║
+║ Procesos CPU:      ${this.padRight(cpuInfo.length + '', 15)} ║ Uptime Proceso:   ${this.padRight(this.formatUptime(uptime), 15)} ║
+╠════════════════════════════════════════════════════════════════╣
+║ Información del Proceso                                        ║
+╠────────────────────────────────────────────────────────────────╣
+║ PID:               ${this.padRight(pid + '', 15)} ║ PPID:             ${this.padRight(ppid + '', 15)} ║
+║ Versión Node:      ${this.padRight(version, 15)} ║ Ruta Ejecutable:  ${this.padRight(execPath.split('/').pop().substring(0, 15), 15)} ║
+╠════════════════════════════════════════════════════════════════╣
+║ Uso de Memoria del Proceso                                     ║
+╠────────────────────────────────────────────────────────────────╣
+║ RSS:               ${this.padRight(this.formatBytes(memUsage.rss), 15)} ║ Heap Total:       ${this.padRight(this.formatBytes(memUsage.heapTotal), 15)} ║
+║ Heap Usado:        ${this.padRight(this.formatBytes(memUsage.heapUsed), 15)} ║ External:         ${this.padRight(this.formatBytes(memUsage.external), 15)} ║
+╚════════════════════════════════════════════════════════════════╝\x1b[0m`;
+
+    socket.write(table + '\n\n');
+    socket.write(`> `);
+  }
+
+  /**
+   * Formatea bytes a una unidad legible
+   * @param {number} bytes - Cantidad en bytes
+   * @returns {string} - Cantidad formateada con unidad
+   */
+  formatBytes(bytes) {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+  }
+
+  /**
+   * Formatea el uptime en una cadena legible
+   * @param {number} seconds - Segundos de uptime
+   * @returns {string} - Uptime formateado
+   */
+  formatUptime(seconds) {
+    const days = Math.floor(seconds / (3600 * 24));
+    const hours = Math.floor((seconds % (3600 * 24)) / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+
+    let result = '';
+    if (days > 0) result += `${days}d `;
+    if (hours > 0) result += `${hours}h `;
+    if (minutes > 0) result += `${minutes}m `;
+    result += `${secs}s`;
+
+    return result.trim();
+  }
+
+  /**
+   * Ajusta texto a la derecha con padding
+   * @param {string} str - Texto a ajustar
+   * @param {number} length - Longitud total
+   * @returns {string} - Texto ajustado
+   */
+  padRight(str, length) {
+    str = str + '';
+    return str.length < length ? str + ' '.repeat(length - str.length) : str.substring(0, length);
+  }
+}
+
+module.exports = SystemModule;

package/lib/admin/modules/TimeModule.js

@@ -0,0 +1,95 @@
+/**
+ * Módulo de Tiempo para la Extensión de Administración de JERK Framework
+ * Módulo personalizado para mostrar hora y fecha
+ */
+
+class TimeModule {
+  /**
+   * Constructor del módulo de tiempo
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.name = 'Time Module';
+    this.description = 'Módulo para mostrar hora y fecha';
+    this.commands = ['time', 'date'];
+  }
+
+  /**
+   * Manejador para los comandos del módulo de tiempo
+   * @param {string} command - Comando a ejecutar
+   * @param {Object} socket - Socket de la conexión
+   */
+  handleCommand(command, socket) {
+    switch (command) {
+      case 'time':
+        this.showTime(socket);
+        break;
+      case 'date':
+        this.showDate(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de tiempo: ${command}\n`);
+        socket.write(`Comandos disponibles: time, date\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Muestra la hora actual en color azul
+   * @param {Object} socket - Socket de la conexión
+   */
+  showTime(socket) {
+    const currentTime = new Date().toLocaleTimeString('es-ES', { 
+      hour: '2-digit', 
+      minute: '2-digit', 
+      second: '2-digit',
+      hour12: false
+    });
+    
+    // Enviar con código de color azul ANSI
+    socket.write(`\n\x1b[34mHora actual: ${currentTime}\x1b[0m\n\n`);
+    socket.write(`> `);
+  }
+
+  /**
+   * Muestra la fecha actual en color azul
+   * @param {Object} socket - Socket de la conexión
+   */
+  showDate(socket) {
+    const currentDate = new Date().toLocaleDateString('es-ES', { 
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric'
+    });
+    
+    // Enviar con código de color azul ANSI
+    socket.write(`\n\x1b[34mFecha actual: ${currentDate}\x1b[0m\n\n`);
+    socket.write(`> `);
+  }
+
+  /**
+   * Muestra la fecha y hora actual en color azul
+   * @param {Object} socket - Socket de la conexión
+   */
+  showDateTime(socket) {
+    const now = new Date();
+    const dateTime = now.toLocaleString('es-ES', { 
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+      hour: '2-digit', 
+      minute: '2-digit', 
+      second: '2-digit',
+      hour12: false
+    });
+    
+    // Enviar con código de color azul ANSI
+    socket.write(`\n\x1b[34mFecha y hora actual: ${dateTime}\x1b[0m\n\n`);
+    socket.write(`> `);
+  }
+}
+
+module.exports = TimeModule;

package/lib/cache/CacheHooks.js

@@ -0,0 +1,141 @@
+/**
+ * Sistema de Hooks y Filters para el Manejo de Caché en JERK Framework
+ * Implementación del componente cache/cacheHooks.js
+ */
+
+class CacheHooks {
+  /**
+   * Constructor del sistema de hooks de caché
+   * @param {Object} hooksSystem - Instancia del sistema de hooks principal
+   */
+  constructor(hooksSystem) {
+    this.hooks = hooksSystem;
+    this.initializeCacheHooks();
+  }
+
+  /**
+   * Inicializa los hooks relacionados con el sistema de caché
+   */
+  initializeCacheHooks() {
+    // Hook para cuando se añade una entrada al caché de rutas
+    this.hooks.addAction('route_regex_cached', (path, regex) => {
+      console.log(`[CACHE] Expresión regular cacheada para ruta: ${path}`);
+    });
+
+    // Hook para cuando se añade una vista al caché
+    this.hooks.addAction('view_cached', (viewPath, content) => {
+      console.log(`[CACHE] Vista cacheada: ${viewPath}`);
+    });
+
+    // Hook para cuando se limpia el caché de rutas
+    this.hooks.addAction('route_cache_cleared', () => {
+      console.log('[CACHE] Caché de rutas limpiado');
+    });
+
+    // Hook para cuando se limpia el caché de vistas
+    this.hooks.addAction('view_cache_cleared', () => {
+      console.log('[CACHE] Caché de vistas limpiado');
+    });
+
+    // Filter para permitir modificar el contenido antes de ser cacheado
+    this.hooks.addFilter('before_view_cache', (content, viewPath) => {
+      // Permitir a otros módulos modificar el contenido antes de cachear
+      return content;
+    });
+
+    // Filter para permitir modificar la decisión de si se debe cachear una vista
+    this.hooks.addFilter('should_cache_view', (shouldCache, viewPath, content) => {
+      // Por defecto, se cachea si está habilitado globalmente
+      return shouldCache;
+    });
+
+    // Filter para permitir modificar la decisión de si se debe cachear una expresión regular
+    this.hooks.addFilter('should_cache_route_regex', (shouldCache, path, regex) => {
+      // Por defecto, se cachea si está habilitado globalmente
+      return shouldCache;
+    });
+  }
+
+  /**
+   * Dispara el hook cuando se añade una entrada al caché de rutas
+   * @param {string} path - Ruta que se está cacheando
+   * @param {RegExp} regex - Expresión regular que se está cacheando
+   */
+  triggerRouteRegexCached(path, regex) {
+    if (this.hooks) {
+      this.hooks.doAction('route_regex_cached', path, regex);
+    }
+  }
+
+  /**
+   * Dispara el hook cuando se añade una vista al caché
+   * @param {string} viewPath - Ruta de la vista que se está cacheando
+   * @param {string} content - Contenido de la vista que se está cacheando
+   */
+  triggerViewCached(viewPath, content) {
+    if (this.hooks) {
+      this.hooks.doAction('view_cached', viewPath, content);
+    }
+  }
+
+  /**
+   * Dispara el hook cuando se limpia el caché de rutas
+   */
+  triggerRouteCacheCleared() {
+    if (this.hooks) {
+      this.hooks.doAction('route_cache_cleared');
+    }
+  }
+
+  /**
+   * Dispara el hook cuando se limpia el caché de vistas
+   */
+  triggerViewCacheCleared() {
+    if (this.hooks) {
+      this.hooks.doAction('view_cache_cleared');
+    }
+  }
+
+  /**
+   * Aplica el filter antes de cachear una vista
+   * @param {string} content - Contenido de la vista
+   * @param {string} viewPath - Ruta de la vista
+   * @returns {string} - Contenido procesado por los filters
+   */
+  applyBeforeViewCacheFilter(content, viewPath) {
+    if (this.hooks) {
+      return this.hooks.applyFilters('before_view_cache', content, viewPath);
+    }
+    return content;
+  }
+
+  /**
+   * Aplica el filter para decidir si se debe cachear una vista
+   * @param {boolean} shouldCache - Valor por defecto
+   * @param {string} viewPath - Ruta de la vista
+   * @param {string} content - Contenido de la vista
+   * @returns {boolean} - Decisión final de si se debe cachear
+   */
+  applyShouldCacheViewFilter(shouldCache, viewPath, content) {
+    if (this.hooks) {
+      return this.hooks.applyFilters('should_cache_view', shouldCache, viewPath, content);
+    }
+    return shouldCache;
+  }
+
+  /**
+   * Aplica el filter para decidir si se debe cachear una expresión regular
+   * @param {boolean} shouldCache - Valor por defecto
+   * @param {string} path - Ruta para la que se va a cachear la expresión regular
+   * @param {RegExp} regex - Expresión regular a cachear
+   * @returns {boolean} - Decisión final de si se debe cachear
+   */
+  applyShouldCacheRouteRegexFilter(shouldCache, path, regex) {
+    if (this.hooks) {
+      return this.hooks.applyFilters('should_cache_route_regex', shouldCache, path, regex);
+    }
+    return shouldCache;
+  }
+}
+
+module.exports = CacheHooks;