jerkjs 2.5.8 → 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

@@ -63,6 +63,21 @@ Las estadísticas se actualizan directamente en el servidor en los siguientes pu
 - 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.

package/lib/admin/modules/ViewCacheStatsModule.js

@@ -0,0 +1,92 @@
+/**
+ * Módulo de Estadísticas del Caché de Vistas para la Extensión de Administración de JERK Framework
+ * Módulo personalizado para mostrar estadísticas del caché de vistas
+ */
+
+class ViewCacheStatsModule {
+  /**
+   * Constructor del módulo de estadísticas del caché de vistas
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.name = 'View Cache Statistics Module';
+    this.description = 'Módulo para mostrar estadísticas del caché de vistas';
+    this.commands = ['view-cache'];
+    
+    // Cargar el objeto global de estadísticas del caché de vistas
+    this.globalViewCacheInfo = require('../../utils/globalViewCacheInfo').globalViewCacheInfo;
+  }
+
+  /**
+   * Manejador para los comandos del módulo de estadísticas del caché de vistas
+   * @param {string} command - Comando a ejecutar
+   * @param {Object} socket - Socket de la conexión
+   */
+  handleCommand(command, socket) {
+    switch (command) {
+      case 'view-cache':
+      case 'vcache':
+      case 'view-stats':
+        this.showViewCacheStats(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de estadísticas del caché de vistas: ${command}\n`);
+        socket.write(`Comandos disponibles: view-cache, vcache, view-stats\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Muestra estadísticas del caché de vistas
+   * @param {Object} socket - Socket de la conexión
+   */
+  showViewCacheStats(socket) {
+    const { cacheStats, viewCache, viewDependencies } = this.globalViewCacheInfo;
+    
+    // Codigos de color ANSI
+    const RESET = '\x1b[0m';
+    const BOLD = '\x1b[1m';
+    const GREEN = '\x1b[32m';
+    const YELLOW = '\x1b[33m';
+    const BLUE = '\x1b[34m';
+    const CYAN = '\x1b[36m';
+    const MAGENTA = '\x1b[35m';
+    
+    socket.write(`\n${BOLD}${CYAN}=== Estadísticas del Caché de Vistas ===${RESET}\n`);
+    socket.write(`${GREEN}Vistas en caché:${RESET} ${viewCache.size}\n`);
+    socket.write(`${YELLOW}Hits (accesos exitosos):${RESET} ${cacheStats.hits}\n`);
+    socket.write(`${YELLOW}Misses (cargas desde disco):${RESET} ${cacheStats.misses}\n`);
+    socket.write(`${GREEN}Total de vistas únicas:${RESET} ${cacheStats.totalViews}\n`);
+    
+    if (cacheStats.hits + cacheStats.misses > 0) {
+      const hitRate = (cacheStats.hits / (cacheStats.hits + cacheStats.misses) * 100).toFixed(2);
+      socket.write(`${BLUE}Tasa de aciertos:${RESET} ${hitRate}%\n`);
+    }
+    
+    // Mostrar vistas más usadas (basado en el tamaño del caché)
+    if (viewCache.size > 0) {
+      socket.write(`\n${BOLD}${MAGENTA}Vistas en caché:${RESET}\n`);
+      for (const [viewPath, content] of viewCache) {
+        socket.write(`  ${viewPath} (${content.length} chars)\n`);
+      }
+    }
+    
+    // Mostrar dependencias de vistas
+    if (viewDependencies.size > 0) {
+      socket.write(`\n${BOLD}${MAGENTA}Dependencias de vistas (inclusiones):${RESET}\n`);
+      for (const [viewPath, dependencies] of viewDependencies) {
+        if (dependencies.size > 0) {
+          socket.write(`  ${viewPath}:\n`);
+          for (const dependency of dependencies) {
+            socket.write(`    - ${dependency}\n`);
+          }
+        }
+      }
+    }
+    
+    socket.write(`\n${RESET}> `);
+  }
+}
+
+module.exports = ViewCacheStatsModule;