jerkjs 2.5.6 → 2.6.1

package/lib/admin/modules/CacheModule.js

@@ -0,0 +1,145 @@
+/**
+ * Módulo de Caché para la Extensión de Administración de JERK Framework
+ * Submódulo personalizado para mostrar y gestionar el sistema de caché
+ */
+
+class CacheModule {
+  /**
+   * Constructor del módulo de caché
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.name = 'Cache Module';
+    this.description = 'Módulo para administrar y monitorear el sistema de caché';
+    this.commands = ['cache', 'cache-stats', 'cache-clear', 'cache-info'];
+  }
+
+  /**
+   * Manejador para los comandos del módulo de caché
+   * @param {string} command - Comando a ejecutar
+   * @param {Object} socket - Socket de la conexión
+   */
+  handleCommand(command, socket) {
+    switch (command) {
+      case 'cache':
+      case 'cache-info':
+        this.showCacheInfo(socket);
+        break;
+      case 'cache-stats':
+        this.showCacheStats(socket);
+        break;
+      case 'cache-clear':
+        this.clearCache(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de caché: ${command}\n`);
+        socket.write(`Comandos disponibles: cache, cache-info, cache-stats, cache-clear\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Muestra información general del sistema de caché
+   * @param {Object} socket - Socket de la conexión
+   */
+  showCacheInfo(socket) {
+    const routeMatcher = this.getRouteMatcher();
+    const viewEngine = this.getViewEngine();
+    
+    const routeCacheSize = routeMatcher ? routeMatcher.routeRegexCache.size : 0;
+    const viewCacheSize = viewEngine ? (viewEngine.viewCache ? viewEngine.viewCache.size : 0) : 0;
+    
+    socket.write('\n=== Información del Sistema de Caché ===\n');
+    socket.write(`Caché de Expresiones Regulares: ${routeCacheSize} entradas\n`);
+    socket.write(`Caché de Vistas: ${viewCacheSize} entradas\n`);
+    socket.write(`\n> `);
+  }
+
+  /**
+   * Muestra estadísticas detalladas del sistema de caché
+   * @param {Object} socket - Socket de la conexión
+   */
+  showCacheStats(socket) {
+    const routeMatcher = this.getRouteMatcher();
+    const viewEngine = this.getViewEngine();
+    
+    const routeCacheSize = routeMatcher ? routeMatcher.routeRegexCache.size : 0;
+    const viewCacheSize = viewEngine ? (viewEngine.viewCache ? viewEngine.viewCache.size : 0) : 0;
+    
+    socket.write('\n=== Estadísticas del Sistema de Caché ===\n');
+    socket.write(`Tamaño del caché de rutas: ${routeCacheSize}\n`);
+    socket.write(`Tamaño del caché de vistas: ${viewCacheSize}\n`);
+    
+    // Mostrar algunos elementos del caché si existen
+    if (routeMatcher && routeMatcher.routeRegexCache.size > 0) {
+      socket.write('\nEntradas de caché de rutas (primeras 5):\n');
+      let count = 0;
+      for (const [path, regex] of routeMatcher.routeRegexCache) {
+        if (count >= 5) break;
+        socket.write(`  ${path}: ${regex}\n`);
+        count++;
+      }
+    }
+    
+    if (viewEngine && viewEngine.viewCache && viewEngine.viewCache.size > 0) {
+      socket.write('\nEntradas de caché de vistas (primeras 5):\n');
+      let count = 0;
+      for (const [path, content] of viewEngine.viewCache) {
+        if (count >= 5) break;
+        socket.write(`  ${path}: ${content.length} chars\n`);
+        count++;
+      }
+    }
+    
+    socket.write(`\n> `);
+  }
+
+  /**
+   * Limpia todos los sistemas de caché
+   * @param {Object} socket - Socket de la conexión
+   */
+  clearCache(socket) {
+    const routeMatcher = this.getRouteMatcher();
+    const viewEngine = this.getViewEngine();
+    
+    let clearedSystems = [];
+    
+    if (routeMatcher) {
+      routeMatcher.clearCache(); // Usar el nuevo método que dispara hooks
+      clearedSystems.push('caché de rutas');
+    }
+    
+    if (viewEngine && viewEngine.viewCache) {
+      viewEngine.clearCache(); // Usar el nuevo método que dispara hooks
+      clearedSystems.push('caché de vistas');
+    }
+    
+    socket.write(`\nSistemas de caché limpiados: ${clearedSystems.join(', ')}\n`);
+    socket.write(`\n> `);
+  }
+
+  /**
+   * Obtiene la instancia de RouteMatcher si está disponible
+   * @returns {Object|null} - Instancia de RouteMatcher o null
+   */
+  getRouteMatcher() {
+    if (this.adminExtension.frameworkInstance && this.adminExtension.frameworkInstance.routeMatcher) {
+      return this.adminExtension.frameworkInstance.routeMatcher;
+    }
+    return null;
+  }
+
+  /**
+   * Obtiene la instancia de ViewEngine si está disponible
+   * @returns {Object|null} - Instancia de ViewEngine o null
+   */
+  getViewEngine() {
+    if (this.adminExtension.frameworkInstance && this.adminExtension.frameworkInstance.viewEngine) {
+      return this.adminExtension.frameworkInstance.viewEngine;
+    }
+    return null;
+  }
+}
+
+module.exports = CacheModule;

package/lib/admin/modules/ControllerGeneratorModule.js

@@ -0,0 +1,414 @@
+/**
+ * Módulo de Generación de Controladores para la Extensión de Administración de JERK Framework
+ * Módulo personalizado para crear controladores de manera interactiva
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ControllerGeneratorModule {
+  /**
+   * Constructor del módulo de generación de controladores
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.name = 'Controller Generator Module';
+    this.description = 'Módulo para crear controladores de manera interactiva';
+    this.commands = ['generate-controller', 'gen-ctrl', 'new-ctrl'];
+    
+    // Estado para el proceso interactivo
+    this.currentProcess = new Map(); // Almacena el estado de generación por socket
+  }
+
+  /**
+   * Manejador para los comandos del módulo de generación de controladores
+   * @param {string} command - Comando a ejecutar
+   * @param {Object} socket - Socket de la conexión
+   */
+  handleCommand(command, socket) {
+    switch (command) {
+      case 'generate-controller':
+      case 'gen-ctrl':
+      case 'new-ctrl':
+        this.startControllerGeneration(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de generación de controladores: ${command}\n`);
+        socket.write(`Comandos disponibles: generate-controller, gen-ctrl, new-ctrl\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Inicia el proceso interactivo de generación de controlador
+   * @param {Object} socket - Socket de la conexión
+   */
+  startControllerGeneration(socket) {
+    const sessionId = this.getSessionId(socket);
+    
+    // Inicializar el estado de la sesión
+    this.currentProcess.set(sessionId, {
+      step: 'name',
+      controllerData: {}
+    });
+    
+    socket.write('\n=== Generador de Controladores ===\n');
+    socket.write('Por favor, introduce el nombre del controlador (sin la palabra "Controller"):\n');
+    socket.write('(Ej: "User", "Product", "Home")\n');
+    socket.write('Para cancelar, escribe "cancel"\n');
+    socket.write('> ');
+  }
+
+  /**
+   * 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 "generate-controller" para iniciar.\n> ');
+      return;
+    }
+    
+    const userInput = input.trim();
+    
+    if (userInput.toLowerCase() === 'cancel') {
+      this.cancelProcess(socket, sessionId);
+      return;
+    }
+    
+    switch (processState.step) {
+      case 'name':
+        this.handleControllerName(socket, sessionId, userInput);
+        break;
+      case 'methods':
+        this.handleMethodsSelection(socket, sessionId, userInput);
+        break;
+      case 'confirm':
+        this.handleConfirmation(socket, sessionId, userInput);
+        break;
+      case 'path':
+        this.handleControllerPath(socket, sessionId, userInput);
+        break;
+    }
+  }
+
+  /**
+   * Maneja la entrada del nombre del controlador
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} name - Nombre del controlador
+   */
+  handleControllerName(socket, sessionId, name) {
+    if (!name) {
+      socket.write('El nombre no puede estar vacío. Por favor, introduce un nombre válido:\n> ');
+      return;
+    }
+    
+    // Validar nombre (solo letras, números y guiones bajos)
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+      socket.write('Nombre inválido. Usa solo letras, números y guiones bajos, comenzando con una letra o guión bajo:\n> ');
+      return;
+    }
+    
+    const processState = this.currentProcess.get(sessionId);
+    processState.controllerData.name = name;
+    processState.step = 'methods';
+    
+    socket.write(`\nNombre del controlador: ${name}Controller\n`);
+    socket.write('\nSelecciona los métodos que deseas incluir (separados por comas):\n');
+    socket.write('Opciones disponibles:\n');
+    socket.write('  1. index - Método para mostrar lista de elementos\n');
+    socket.write('  2. show - Método para mostrar un elemento específico\n');
+    socket.write('  3. create - Método para crear un nuevo elemento\n');
+    socket.write('  4. update - Método para actualizar un elemento\n');
+    socket.write('  5. delete - Método para eliminar un elemento\n');
+    socket.write('  6. All - Todos los métodos anteriores\n');
+    socket.write('\nEjemplos: "1,2,3" o "index,show,create" o "All"\n> ');
+  }
+
+  /**
+   * Maneja la selección de métodos
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} selection - Selección de métodos
+   */
+  handleMethodsSelection(socket, sessionId, selection) {
+    const processState = this.currentProcess.get(sessionId);
+    const methodsMap = {
+      '1': 'index', '2': 'show', '3': 'create', '4': 'update', '5': 'delete'
+    };
+    
+    let selectedMethods = [];
+    
+    if (selection.toLowerCase() === 'all') {
+      selectedMethods = ['index', 'show', 'create', 'update', 'delete'];
+    } else {
+      // Separar por comas y procesar cada selección
+      const selections = selection.split(',').map(s => s.trim());
+      
+      for (const sel of selections) {
+        if (methodsMap[sel]) {
+          selectedMethods.push(methodsMap[sel]);
+        } else if (['index', 'show', 'create', 'update', 'delete'].includes(sel)) {
+          selectedMethods.push(sel);
+        } else {
+          socket.write(`Selección inválida: ${sel}. Por favor, selecciona métodos válidos:\n> `);
+          return;
+        }
+      }
+    }
+    
+    // Eliminar duplicados
+    selectedMethods = [...new Set(selectedMethods)];
+    
+    processState.controllerData.methods = selectedMethods;
+    processState.step = 'path';
+    
+    socket.write(`\nMétodos seleccionados: ${selectedMethods.join(', ')}\n`);
+    socket.write('\nIndica la ruta donde deseas crear el archivo del controlador:\n');
+    socket.write('(Ruta relativa desde la raíz del proyecto, ej: "./controllers/", "./src/controllers/")\n');
+    socket.write('Deja vacío para usar "./controllers/" por defecto:\n> ');
+  }
+
+  /**
+   * Maneja la selección de la ruta del controlador
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} pathInput - Ruta ingresada
+   */
+  handleControllerPath(socket, sessionId, pathInput) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    // Usar la ruta por defecto si no se proporciona ninguna
+    const controllerPath = pathInput.trim() || './controllers/';
+    
+    // Asegurarse de que termine con '/'
+    const normalizedPath = controllerPath.endsWith('/') ? controllerPath : controllerPath + '/';
+    
+    processState.controllerData.path = normalizedPath;
+    processState.step = 'confirm';
+    
+    socket.write(`\nRuta del controlador: ${normalizedPath}\n`);
+    this.showControllerPreview(socket, processState.controllerData);
+  }
+
+  /**
+   * Muestra una vista previa del controlador que se va a generar
+   * @param {Object} socket - Socket de la conexión
+   * @param {Object} controllerData - Datos del controlador
+   */
+  showControllerPreview(socket, controllerData) {
+    socket.write('\n=== Vista Previa del Controlador ===\n');
+    socket.write(`Nombre del archivo: ${controllerData.name}Controller.js\n\n`);
+    
+    let preview = `const ControllerBase = require('../../index.js').ControllerBase;\n\n`;
+    preview += `class ${controllerData.name}Controller extends ControllerBase {\n`;
+    
+    for (const method of controllerData.methods) {
+      preview += this.generateMethodSkeleton(method, controllerData.name);
+    }
+    
+    preview += `}\n\n`;
+    preview += `module.exports = new ${controllerData.name}Controller();\n`;
+    
+    socket.write(preview);
+    socket.write('\n¿Deseas crear este controlador? (sí/no):\n> ');
+  }
+
+  /**
+   * Genera el esqueleto de un método
+   * @param {string} method - Nombre del método
+   * @param {string} controllerName - Nombre del controlador
+   * @returns {string} - Código del método
+   */
+  generateMethodSkeleton(method, controllerName) {
+    let skeleton = '';
+    
+    switch (method) {
+      case 'index':
+        skeleton += `  async index(req, res) {\n`;
+        skeleton += `    try {\n`;
+        skeleton += `      // Lógica para obtener y mostrar una lista de ${controllerName.toLowerCase()}s\n`;
+        skeleton += `      const items = await this.loadModel('${controllerName}Model').then(model => model.find({}));\n`;
+        skeleton += `      \n`;
+        skeleton += `      res.render('${controllerName.toLowerCase()}/index', { \n`;
+        skeleton += `        title: '${controllerName}s',\n`;
+        skeleton += `        items\n`;
+        skeleton += `      });\n`;
+        skeleton += `    } catch (error) {\n`;
+        skeleton += `      console.error('Error en el método index:', error);\n`;
+        skeleton += `      res.writeHead(500, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ error: 'Error interno del servidor' }));\n`;
+        skeleton += `    }\n`;
+        skeleton += `  }\n\n`;
+        break;
+        
+      case 'show':
+        skeleton += `  async show(req, res) {\n`;
+        skeleton += `    try {\n`;
+        skeleton += `      const id = req.params.id;\n`;
+        skeleton += `      // Lógica para obtener y mostrar un ${controllerName.toLowerCase()} específico\n`;
+        skeleton += `      const item = await this.loadModel('${controllerName}Model').then(model => model.findOne({ id: parseInt(id) }));\n`;
+        skeleton += `      \n`;
+        skeleton += `      if (!item) {\n`;
+        skeleton += `        res.writeHead(404, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `        res.end(JSON.stringify({ error: '${controllerName} no encontrado' }));\n`;
+        skeleton += `        return;\n`;
+        skeleton += `      }\n`;
+        skeleton += `      \n`;
+        skeleton += `      res.render('${controllerName.toLowerCase()}/show', { \n`;
+        skeleton += `        title: '${controllerName} #' + id,\n`;
+        skeleton += `        item\n`;
+        skeleton += `      });\n`;
+        skeleton += `    } catch (error) {\n`;
+        skeleton += `      console.error('Error en el método show:', error);\n`;
+        skeleton += `      res.writeHead(500, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ error: 'Error interno del servidor' }));\n`;
+        skeleton += `    }\n`;
+        skeleton += `  }\n\n`;
+        break;
+        
+      case 'create':
+        skeleton += `  async create(req, res) {\n`;
+        skeleton += `    try {\n`;
+        skeleton += `      // Lógica para crear un nuevo ${controllerName.toLowerCase()}\n`;
+        skeleton += `      const data = req.body;\n`;
+        skeleton += `      const newItem = await this.loadModel('${controllerName}Model').then(model => model.create(data));\n`;
+        skeleton += `      \n`;
+        skeleton += `      res.writeHead(201, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ success: true, data: newItem }));\n`;
+        skeleton += `    } catch (error) {\n`;
+        skeleton += `      console.error('Error en el método create:', error);\n`;
+        skeleton += `      res.writeHead(400, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ error: error.message }));\n`;
+        skeleton += `    }\n`;
+        skeleton += `  }\n\n`;
+        break;
+        
+      case 'update':
+        skeleton += `  async update(req, res) {\n`;
+        skeleton += `    try {\n`;
+        skeleton += `      const id = req.params.id;\n`;
+        skeleton += `      const data = req.body;\n`;
+        skeleton += `      // Lógica para actualizar un ${controllerName.toLowerCase()} existente\n`;
+        skeleton += `      const result = await this.loadModel('${controllerName}Model').then(model => model.update({ id: parseInt(id) }, data));\n`;
+        skeleton += `      \n`;
+        skeleton += `      res.writeHead(200, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ success: true, data: result }));\n`;
+        skeleton += `    } catch (error) {\n`;
+        skeleton += `      console.error('Error en el método update:', error);\n`;
+        skeleton += `      res.writeHead(400, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ error: error.message }));\n`;
+        skeleton += `    }\n`;
+        skeleton += `  }\n\n`;
+        break;
+        
+      case 'delete':
+        skeleton += `  async delete(req, res) {\n`;
+        skeleton += `    try {\n`;
+        skeleton += `      const id = req.params.id;\n`;
+        skeleton += `      // Lógica para eliminar un ${controllerName.toLowerCase()}\n`;
+        skeleton += `      const result = await this.loadModel('${controllerName}Model').then(model => model.delete({ id: parseInt(id) }));\n`;
+        skeleton += `      \n`;
+        skeleton += `      res.writeHead(200, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ success: true, message: '${controllerName} eliminado correctamente' }));\n`;
+        skeleton += `    } catch (error) {\n`;
+        skeleton += `      console.error('Error en el método delete:', error);\n`;
+        skeleton += `      res.writeHead(400, { 'Content-Type': 'application/json' });\n`;
+        skeleton += `      res.end(JSON.stringify({ error: error.message }));\n`;
+        skeleton += `    }\n`;
+        skeleton += `  }\n\n`;
+        break;
+    }
+    
+    return skeleton;
+  }
+
+  /**
+   * Maneja la confirmación de creación del controlador
+   * @param {Object} socket - Socket de la conexión
+   * @param {string} sessionId - ID de la sesión
+   * @param {string} confirmation - Confirmación del usuario
+   */
+  handleConfirmation(socket, sessionId, confirmation) {
+    const processState = this.currentProcess.get(sessionId);
+    
+    if (confirmation.toLowerCase() === 'sí' || confirmation.toLowerCase() === 'si' || confirmation.toLowerCase() === 'yes') {
+      this.createControllerFile(socket, processState.controllerData);
+    } else {
+      socket.write('\nGeneración del controlador cancelada.\n> ');
+      this.currentProcess.delete(sessionId);
+    }
+  }
+
+  /**
+   * Crea el archivo del controlador
+   * @param {Object} socket - Socket de la conexión
+   * @param {Object} controllerData - Datos del controlador
+   */
+  createControllerFile(socket, controllerData) {
+    const { name, methods, path: controllerPath } = controllerData;
+    
+    // Crear el contenido del archivo
+    let content = `const ControllerBase = require('../../index.js').ControllerBase;\n\n`;
+    content += `class ${name}Controller extends ControllerBase {\n`;
+    
+    for (const method of methods) {
+      content += this.generateMethodSkeleton(method, name);
+    }
+    
+    content += `}\n\n`;
+    content += `module.exports = new ${name}Controller();\n`;
+    
+    // Crear directorio si no existe
+    const fullPath = path.join(process.cwd(), controllerPath);
+    if (!fs.existsSync(fullPath)) {
+      fs.mkdirSync(fullPath, { recursive: true });
+    }
+    
+    // Ruta completa del archivo
+    const filePath = path.join(fullPath, `${name}Controller.js`);
+    
+    try {
+      // Escribir el archivo
+      fs.writeFileSync(filePath, content);
+      
+      socket.write(`\n✅ Controlador "${name}Controller" creado exitosamente en:\n${filePath}\n`);
+      socket.write(`\nMétodos incluidos: ${methods.join(', ')}\n`);
+      socket.write('\n> ');
+    } catch (error) {
+      socket.write(`\n❌ Error al crear el archivo: ${error.message}\n> `);
+    }
+    
+    // Limpiar el estado
+    const sessionId = this.getSessionId(socket);
+    this.currentProcess.delete(sessionId);
+  }
+
+  /**
+   * Cancela el proceso de generación
+   * @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 = ControllerGeneratorModule;