jerkjs 2.5.6 → 2.6.1

package/lib/admin/modules/RouteManagerModule.js

@@ -0,0 +1,468 @@
+/**
+ * Módulo de Gestión de Rutas para la Extensión de Administración de JERK Framework
+ * Módulo personalizado para crear y deshabilitar rutas de manera interactiva
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class RouteManagerModule {
+  /**
+   * Constructor del módulo de gestión de rutas
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.name = 'Route Manager Module';
+    this.description = 'Módulo para crear y deshabilitar rutas de manera interactiva';
+    this.commands = ['manage-routes', 'route-manager', 'route-mgmt'];
+    
+    // Estado para el proceso interactivo
+    this.currentProcess = new Map(); // Almacena el estado de gestión por socket
+  }
+
+  /**
+   * Manejador para los comandos del módulo de gestión de rutas
+   * @param {string} command - Comando a ejecutar
+   * @param {Object} socket - Socket de la conexión
+   */
+  handleCommand(command, socket) {
+    switch (command) {
+      case 'manage-routes':
+      case 'route-manager':
+      case 'route-mgmt':
+        this.startRouteManagement(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de gestión de rutas: ${command}\n`);
+        socket.write(`Comandos disponibles: manage-routes, route-manager, route-mgmt\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Inicia el proceso interactivo de gestión de rutas
+   * @param {Object} socket - Socket de la conexión
+   */
+  startRouteManagement(socket) {
+    const sessionId = this.getSessionId(socket);
+    
+    // Inicializar el estado de la sesión
+    this.currentProcess.set(sessionId, {
+      step: 'action',
+      routeData: {}
+    });
+    
+    socket.write('\n=== Gestión de Rutas ===\n');
+    socket.write('¿Qué deseas hacer?\n');
+    socket.write('1. Crear nueva ruta\n');
+    socket.write('2. Deshabilitar ruta existente\n');
+    socket.write('3. Ver rutas registradas\n');
+    socket.write('4. Ver rutas activas\n');
+    socket.write('\nEscribe el número de la opción (1-4) o "cancel" para cancelar:\n> ');
+  }
+
+  /**
+   * Obtiene un ID único para la sesión del socket
+   * @param {Object} socket - Socket de la conexión
+   * @returns {string} - ID de sesión
+   */
+  getSessionId(socket) {
+    // Usar la dirección remota y puerto como identificador único
+    return `${socket.remoteAddress}:${socket.remotePort}`;
+  }
+
+  /**
+   * Procesa la entrada del usuario durante el proceso interactivo
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} input - Entrada del usuario
+   */
+  processInput(socket, input) {
+    const sessionId = this.getSessionId(socket);
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (!processState) {
+      socket.write('No hay proceso activo. Usa "manage-routes" para iniciar.\n> ');
+      return;
+    }
+    
+    const userInput = input.trim();
+    
+    if (userInput.toLowerCase() === 'cancel') {
+      this.cancelProcess(socket, sessionId);
+      return;
+    }
+    
+    switch (processState.step) {
+      case 'action':
+        this.handleActionSelection(socket, sessionId, userInput);
+        break;
+      case 'create_method':
+        this.handleCreateMethod(socket, sessionId, userInput);
+        break;
+      case 'create_path':
+        this.handleCreatePath(socket, sessionId, userInput);
+        break;
+      case 'create_controller':
+        this.handleCreateController(socket, sessionId, userInput);
+        break;
+      case 'create_handler':
+        this.handleCreateHandler(socket, sessionId, userInput);
+        break;
+      case 'create_confirm':
+        this.handleCreateConfirmation(socket, sessionId, userInput);
+        break;
+      case 'disable_select':
+        this.handleDisableSelection(socket, sessionId, userInput);
+        break;
+      case 'disable_confirm':
+        this.handleDisableConfirmation(socket, sessionId, userInput);
+        break;
+      case 'view_routes':
+        if (userInput.toLowerCase() === 'sí' || userInput.toLowerCase() === 'si' || userInput.toLowerCase() === 'yes') {
+          this.showRegisteredRoutes(socket);
+        } else {
+          socket.write('\nVolviendo al menú principal...\n> ');
+          this.resetProcess(socket);
+        }
+        break;
+    }
+  }
+
+  /**
+   * Maneja la selección de acción (crear, deshabilitar, ver rutas)
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} selection - Selección del usuario
+   */
+  handleActionSelection(socket, sessionId, selection) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    switch (selection) {
+      case '1':
+        processState.step = 'create_method';
+        processState.action = 'create';
+        socket.write('\n=== Crear Nueva Ruta ===\n');
+        socket.write('Selecciona el método HTTP:\n');
+        socket.write('1. GET\n2. POST\n3. PUT\n4. DELETE\n5. PATCH\n6. Otro\n');
+        socket.write('Escribe el número o el método directamente (GET, POST, etc.):\n> ');
+        break;
+      case '2':
+        processState.step = 'disable_select';
+        processState.action = 'disable';
+        this.listAvailableRoutes(socket);
+        break;
+      case '3':
+        this.showRegisteredRoutes(socket);
+        this.resetProcess(socket);
+        break;
+      case '4':
+        this.showActiveRoutes(socket);
+        this.resetProcess(socket);
+        break;
+      default:
+        socket.write('Opción inválida. Por favor, selecciona 1, 2, 3 o 4:\n> ');
+    }
+  }
+
+  /**
+   * Muestra las rutas registradas
+   * @param {Object} socket - Socket de la conexión
+   */
+  showRegisteredRoutes(socket) {
+    if (this.adminExtension.registeredRoutes && this.adminExtension.registeredRoutes.length > 0) {
+      socket.write('\n=== Rutas Registradas ===\n');
+      this.adminExtension.registeredRoutes.forEach((route, index) => {
+        socket.write(`${index + 1}. ${route.method} ${route.path}\n`);
+      });
+    } else {
+      socket.write('\n=== Rutas Registradas ===\n');
+      socket.write('No hay rutas registradas.\n');
+    }
+    socket.write('\n> ');
+  }
+
+  /**
+   * Muestra las rutas activas
+   * @param {Object} socket - Socket de la conexión
+   */
+  showActiveRoutes(socket) {
+    if (this.adminExtension.activeRoutes && this.adminExtension.activeRoutes.size > 0) {
+      socket.write('\n=== Rutas Activas ===\n');
+      for (const [url, info] of this.adminExtension.activeRoutes) {
+        socket.write(`${info.method} ${url} - ${info.timestamp} (${info.remoteAddress})\n`);
+      }
+    } else {
+      socket.write('\n=== Rutas Activas ===\n');
+      socket.write('No hay rutas activas registradas.\n');
+    }
+    socket.write('\n> ');
+  }
+
+  /**
+   * Lista las rutas disponibles para deshabilitar
+   * @param {Object} socket - Socket de la conexión
+   */
+  listAvailableRoutes(socket) {
+    if (this.adminExtension.registeredRoutes && this.adminExtension.registeredRoutes.length > 0) {
+      socket.write('\n=== Rutas Disponibles para Deshabilitar ===\n');
+      this.adminExtension.registeredRoutes.forEach((route, index) => {
+        socket.write(`${index + 1}. ${route.method} ${route.path}\n`);
+      });
+      socket.write('\nSelecciona el número de la ruta que deseas deshabilitar:\n> ');
+    } else {
+      socket.write('\nNo hay rutas registradas para deshabilitar.\n');
+      socket.write('Volviendo al menú principal...\n> ');
+      this.resetProcess(socket);
+    }
+  }
+
+  /**
+   * Maneja la selección del método HTTP para crear ruta
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} method - Método HTTP seleccionado
+   */
+  handleCreateMethod(socket, sessionId, method) {
+    const processState = this.currentProcess.get(sessionId);
+    const methodMap = {
+      '1': 'GET', '2': 'POST', '3': 'PUT', '4': 'DELETE', '5': 'PATCH', '6': 'OTHER'
+    };
+    
+    let selectedMethod;
+    if (methodMap[method]) {
+      selectedMethod = methodMap[method];
+      if (selectedMethod === 'OTHER') {
+        socket.write('Escribe el método HTTP personalizado:\n> ');
+        return;
+      }
+    } else {
+      selectedMethod = method.toUpperCase();
+    }
+    
+    processState.routeData.method = selectedMethod;
+    processState.step = 'create_path';
+    
+    socket.write(`\nMétodo seleccionado: ${selectedMethod}\n`);
+    socket.write('Introduce la ruta (ej: /api/users, /users/:id):\n> ');
+  }
+
+  /**
+   * Maneja la introducción de la ruta
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} routePath - Ruta introducida
+   */
+  handleCreatePath(socket, sessionId, routePath) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (!routePath || !routePath.startsWith('/')) {
+      socket.write('La ruta debe comenzar con "/". Por favor, introduce una ruta válida:\n> ');
+      return;
+    }
+    
+    processState.routeData.path = routePath;
+    processState.step = 'create_controller';
+    
+    socket.write(`\nRuta: ${routePath}\n`);
+    socket.write('Introduce la ruta al archivo del controlador (ej: ./controllers/UserController.js):\n> ');
+  }
+
+  /**
+   * Maneja la introducción del controlador
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} controller - Ruta al controlador
+   */
+  handleCreateController(socket, sessionId, controller) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (!controller) {
+      socket.write('La ruta al controlador no puede estar vacía. Por favor, introduce una ruta válida:\n> ');
+      return;
+    }
+    
+    processState.routeData.controller = controller;
+    processState.step = 'create_handler';
+    
+    socket.write(`\nControlador: ${controller}\n`);
+    socket.write('Introduce el nombre del método del controlador (ej: index, show, create):\n> ');
+  }
+
+  /**
+   * Maneja la introducción del handler
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} handler - Nombre del handler
+   */
+  handleCreateHandler(socket, sessionId, handler) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (!handler) {
+      socket.write('El nombre del handler no puede estar vacío. Por favor, introduce un nombre válido:\n> ');
+      return;
+    }
+    
+    processState.routeData.handler = handler;
+    processState.step = 'create_confirm';
+    
+    socket.write(`\nHandler: ${handler}\n`);
+    this.showRoutePreview(socket, processState.routeData);
+  }
+
+  /**
+   * Muestra una vista previa de la ruta que se va a crear
+   * @param {Object} socket - Socket de la conexión
+   * @param {Object} routeData - Datos de la ruta
+   */
+  showRoutePreview(socket, routeData) {
+    socket.write('\n=== Vista Previa de la Ruta ===\n');
+    socket.write(`Método: ${routeData.method}\n`);
+    socket.write(`Ruta: ${routeData.path}\n`);
+    socket.write(`Controlador: ${routeData.controller}\n`);
+    socket.write(`Handler: ${routeData.handler}\n\n`);
+    
+    const routeEntry = {
+      path: routeData.path,
+      method: routeData.method,
+      controller: routeData.controller,
+      handler: routeData.handler,
+      contentType: "application/json"
+    };
+    
+    socket.write('Entrada para routes.json:\n');
+    socket.write(JSON.stringify(routeEntry, null, 2) + '\n\n');
+    
+    socket.write('¿Deseas crear esta ruta? (sí/no):\n> ');
+  }
+
+  /**
+   * Maneja la confirmación de creación de ruta
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} confirmation - Confirmación del usuario
+   */
+  handleCreateConfirmation(socket, sessionId, confirmation) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (confirmation.toLowerCase() === 'sí' || confirmation.toLowerCase() === 'si' || confirmation.toLowerCase() === 'yes') {
+      this.createRoute(socket, processState.routeData);
+    } else {
+      socket.write('\nCreación de ruta cancelada.\n> ');
+      this.resetProcess(socket);
+    }
+  }
+
+  /**
+   * Crea la ruta en el sistema
+   * @param {Object} socket - Socket de la conexión
+   * @param {Object} routeData - Datos de la ruta
+   */
+  createRoute(socket, routeData) {
+    // En un entorno real, aquí se agregaría la ruta al servidor
+    // Por ahora, solo mostramos un mensaje de confirmación
+    
+    socket.write(`\n✅ Ruta "${routeData.method} ${routeData.path}" creada exitosamente.\n`);
+    socket.write(`- Controlador: ${routeData.controller}\n`);
+    socket.write(`- Handler: ${routeData.handler}\n`);
+    
+    // Agregar a las rutas registradas
+    if (this.adminExtension.registeredRoutes) {
+      const newRoute = {
+        method: routeData.method,
+        path: routeData.path,
+        controller: routeData.controller,
+        handler: routeData.handler
+      };
+      this.adminExtension.registeredRoutes.push(newRoute);
+    }
+    
+    socket.write('\n> ');
+    this.resetProcess(socket);
+  }
+
+  /**
+   * Maneja la selección de ruta para deshabilitar
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} selection - Selección del usuario
+   */
+  handleDisableSelection(socket, sessionId, selection) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    const routeIndex = parseInt(selection) - 1;
+    
+    if (isNaN(routeIndex) || routeIndex < 0 || routeIndex >= this.adminExtension.registeredRoutes.length) {
+      socket.write('Número de ruta inválido. Por favor, selecciona un número válido:\n> ');
+      return;
+    }
+    
+    processState.routeToDisable = this.adminExtension.registeredRoutes[routeIndex];
+    processState.step = 'disable_confirm';
+    
+    socket.write(`\nRuta seleccionada para deshabilitar:\n`);
+    socket.write(`${processState.routeToDisable.method} ${processState.routeToDisable.path}\n`);
+    socket.write(`¿Estás seguro de que deseas deshabilitar esta ruta? (sí/no):\n> `);
+  }
+
+  /**
+   * Maneja la confirmación de deshabilitación de ruta
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} confirmation - Confirmación del usuario
+   */
+  handleDisableConfirmation(socket, sessionId, confirmation) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (confirmation.toLowerCase() === 'sí' || confirmation.toLowerCase() === 'si' || confirmation.toLowerCase() === 'yes') {
+      this.disableRoute(socket, processState.routeToDisable);
+    } else {
+      socket.write('\nDeshabilitación de ruta cancelada.\n> ');
+      this.resetProcess(socket);
+    }
+  }
+
+  /**
+   * Deshabilita la ruta del sistema
+   * @param {Object} socket - Socket de la conexión
+   * @param {Object} route - Ruta a deshabilitar
+   */
+  disableRoute(socket, route) {
+    // En un entorno real, aquí se removería la ruta del servidor
+    // Por ahora, solo mostramos un mensaje de confirmación
+    
+    socket.write(`\n✅ Ruta "${route.method} ${route.path}" deshabilitada exitosamente.\n`);
+    
+    // Remover de las rutas registradas
+    if (this.adminExtension.registeredRoutes) {
+      const index = this.adminExtension.registeredRoutes.indexOf(route);
+      if (index !== -1) {
+        this.adminExtension.registeredRoutes.splice(index, 1);
+      }
+    }
+    
+    socket.write('\n> ');
+    this.resetProcess(socket);
+  }
+
+  /**
+   * Reinicia el proceso de gestión de rutas
+   * @param {Object} socket - Socket de la conexión
+   */
+  resetProcess(socket) {
+    const sessionId = this.getSessionId(socket);
+    this.currentProcess.delete(sessionId);
+  }
+
+  /**
+   * Cancela el proceso de gestión de rutas
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   */
+  cancelProcess(socket, sessionId) {
+    this.currentProcess.delete(sessionId);
+    socket.write('\nProceso cancelado.\n> ');
+  }
+}
+
+module.exports = RouteManagerModule;

package/lib/admin/modules/STATS_MODULE_README.md

@@ -0,0 +1,113 @@
+# 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`
+
+## Sistema de Caché de Vistas
+
+Además del sistema de estadísticas general, el framework también incluye un sistema de caché de vistas con estadísticas globales:
+
+- `globalViewCacheInfo.viewCache`: Mapa de vistas en caché
+- `globalViewCacheInfo.cacheStats`: Estadísticas de hits/misses
+- `globalViewCacheInfo.viewDependencies`: Registro de dependencias entre vistas (inclusiones)
+
+### Estadísticas del Caché de Vistas
+
+- Hits: Número de accesos exitosos al caché
+- Misses: Número de veces que se leyó desde disco
+- Tasa de aciertos: Porcentaje de accesos exitosos
+- Dependencias: Registro de inclusiones entre vistas
+
+## 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.