jerkjs 2.5.4 → 2.5.8

package/lib/admin/AdminExtension.js

@@ -0,0 +1,436 @@
+/**
+ * Extensión de Administración para JERK Framework
+ * Implementación del componente admin/AdminExtension.js
+ */
+
+const net = require('net');
+const fs = require('fs');
+const path = require('path');
+
+class AdminExtension {
+  /**
+   * Constructor de la extensión de administración
+   * @param {Object} options - Opciones de configuración
+   * @param {number} options.port - Puerto para el servidor de administración
+   * @param {string} options.host - Host para el servidor de administración
+   */
+  constructor(options = {}) {
+    this.port = options.port || 9999;
+    this.host = options.host || '127.0.0.1'; // Solo localhost
+    this.server = null;
+    this.clients = new Set();
+    this.frameworkVersion = this.getFrameworkVersion();
+    this.activeRoutes = new Map(); // Para rastrear rutas activas
+    this.registeredRoutes = []; // Para almacenar rutas registradas
+    this.modules = new Map(); // Para almacenar módulos de administración
+    this.hooks = null; // Referencia al sistema de hooks
+  }
+
+  /**
+   * Obtiene la versión del framework desde package.json
+   * @returns {string} - Versión del framework
+   */
+  getFrameworkVersion() {
+    try {
+      const packagePath = path.join(__dirname, '../../package.json');
+      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+      return packageJson.version || 'unknown';
+    } catch (error) {
+      console.error('Error leyendo la versión del framework:', error.message);
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Inicializa la extensión y el servidor de administración
+   * @param {Object} frameworkInstance - Instancia del framework JERK
+   */
+  initialize(frameworkInstance) {
+    this.frameworkInstance = frameworkInstance;
+
+    // Obtener referencia al sistema de hooks
+    if (frameworkInstance && frameworkInstance.hooks) {
+      this.hooks = frameworkInstance.hooks;
+    } else {
+      // Si no se proporciona, crear uno nuevo
+      const { hooks } = require('../../index.js');
+      this.hooks = hooks;
+    }
+
+    // Registrar hooks para rastrear rutas
+    this.registerHooks();
+
+    // Registrar módulos
+    this.registerModules();
+
+    // Cargar módulos personalizados
+    this.loadCustomModules();
+
+    // Cargar rutas existentes si el servidor ya tiene rutas registradas
+    this.loadExistingRoutes();
+
+    // Iniciar servidor de administración
+    this.startAdminServer();
+  }
+
+  /**
+   * Carga módulos personalizados
+   */
+  loadCustomModules() {
+    try {
+      const ModuleLoader = require('./ModuleLoader');
+      const moduleLoader = new ModuleLoader(this);
+      
+      // Cargar módulos desde el directorio de módulos
+      moduleLoader.loadModulesFromDirectory('./modules');
+    } catch (error) {
+      console.error('Error cargando módulos personalizados:', error.message);
+    }
+  }
+
+  /**
+   * Carga las rutas existentes en el servidor
+   */
+  loadExistingRoutes() {
+    if (this.frameworkInstance && this.frameworkInstance.routes) {
+      // Copiar las rutas existentes al registro de rutas registradas
+      for (const route of this.frameworkInstance.routes) {
+        this.registeredRoutes.push({
+          method: route.method,
+          path: route.path,
+          handler: route.handler,
+          isStatic: route.isStatic
+        });
+      }
+    }
+  }
+
+  /**
+   * Registra los hooks necesarios para rastrear rutas
+   */
+  registerHooks() {
+    if (this.hooks) {
+      // Hook para rastrear rutas registradas
+      this.hooks.addAction('route_registered', (route) => {
+        this.registeredRoutes.push(route);
+      });
+
+      // Hook para rastrear rutas activas
+      this.hooks.addAction('request_received', (req, res) => {
+        const routeInfo = {
+          method: req.method,
+          url: req.url,
+          timestamp: new Date().toISOString(),
+          remoteAddress: req.connection.remoteAddress
+        };
+
+        // Usar la URL como clave y almacenar la última solicitud
+        this.activeRoutes.set(req.url, routeInfo);
+
+        // Disparar hook específico para módulos de administración
+        this.hooks.doAction('admin_route_active', routeInfo);
+      });
+
+      // Hook para cuando se cierra el servidor
+      this.hooks.addAction('server_stopped', () => {
+        this.close();
+      });
+    }
+  }
+
+  /**
+   * Registra los módulos de administración
+   */
+  registerModules() {
+    // Módulo de rutas - el primer módulo
+    this.modules.set('routes', {
+      name: 'Routes Module',
+      description: 'Módulo para ver rutas registradas y activas',
+      commands: ['routes', 'active'],
+      handler: this.handleRoutesCommand.bind(this)
+    });
+
+    // Módulo de sistema - para comandos generales
+    this.modules.set('system', {
+      name: 'System Module',
+      description: 'Módulo para información del sistema',
+      commands: ['version', 'status', 'help'],
+      handler: this.handleSystemCommand.bind(this)
+    });
+
+    // Cargar módulos personalizados
+    this.loadCustomModules();
+  }
+
+  /**
+   * Carga módulos personalizados desde el directorio de módulos
+   */
+  loadCustomModules() {
+    const fs = require('fs');
+    const path = require('path');
+    
+    try {
+      const modulesDir = path.join(__dirname, 'modules');
+      
+      if (fs.existsSync(modulesDir)) {
+        const files = fs.readdirSync(modulesDir);
+        
+        for (const file of files) {
+          if (file.endsWith('.js') && file !== 'index.js') {
+            try {
+              const moduleName = file.replace('.js', '');
+              const ModuleClass = require(path.join(modulesDir, file));
+              
+              if (typeof ModuleClass === 'function') {
+                const moduleInstance = new ModuleClass(this);
+                
+                this.modules.set(moduleName.toLowerCase(), {
+                  name: moduleInstance.name,
+                  description: moduleInstance.description,
+                  commands: moduleInstance.commands,
+                  handler: (command, socket) => moduleInstance.handleCommand(command, socket)
+                });
+                
+                console.log(`Módulo '${moduleName}' cargado exitosamente.`);
+              }
+            } catch (moduleError) {
+              console.error(`Error cargando módulo ${file}:`, moduleError.message);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Error general al cargar módulos personalizados:', error.message);
+    }
+  }
+
+  /**
+   * Manejador para el módulo de rutas
+   */
+  handleRoutesCommand(command, socket) {
+    switch (command) {
+      case 'routes':
+        this.sendRegisteredRoutes(socket);
+        break;
+      case 'active':
+        this.sendActiveRoutes(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de rutas: ${command}\n`);
+        socket.write(`Comandos disponibles: routes, active\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Manejador para el módulo de sistema
+   */
+  handleSystemCommand(command, socket) {
+    switch (command) {
+      case 'version':
+        socket.write(`\nVersión del framework: ${this.frameworkVersion}\n\n`);
+        socket.write(`> `);
+        break;
+      case 'status':
+        socket.write(`\nEstado del servidor:\n`);
+        socket.write(`- Puerto: ${this.port}\n`);
+        socket.write(`- Host: ${this.host}\n`);
+        socket.write(`- Clientes conectados: ${this.clients.size}\n`);
+        socket.write(`- Rutas registradas: ${this.registeredRoutes.length}\n`);
+        socket.write(`- Rutas activas: ${this.activeRoutes.size}\n\n`);
+        socket.write(`> `);
+        break;
+      case 'help':
+        this.sendHelp(socket);
+        break;
+      default:
+        socket.write(`Comando desconocido para el módulo de sistema: ${command}\n`);
+        socket.write(`Comandos disponibles: version, status, help\n\n`);
+        socket.write(`> `);
+    }
+  }
+
+  /**
+   * Inicia el servidor de administración
+   */
+  startAdminServer() {
+    this.server = net.createServer((socket) => {
+      this.clients.add(socket);
+      
+      // Enviar mensaje de bienvenida
+      socket.write(`Bienvenido al Servidor de Administración de JERK Framework\n`);
+      socket.write(`Versión: ${this.frameworkVersion}\n`);
+      socket.write(`Puerto: ${this.port}\n`);
+      socket.write(`Fecha: ${new Date().toISOString()}\n\n`);
+      
+      socket.write(`Módulos disponibles:\n`);
+      for (const [name, module] of this.modules) {
+        socket.write(`  ${name}: ${module.description}\n`);
+      }
+      socket.write(`\n`);
+      
+      socket.write(`Comandos disponibles:\n`);
+      for (const [name, module] of this.modules) {
+        socket.write(`  ${module.commands.join(', ')} - ${module.description}\n`);
+      }
+      socket.write(`  help - Mostrar esta ayuda\n`);
+      socket.write(`  quit - Cerrar conexión\n\n`);
+      
+      socket.write(`> `);
+
+      socket.on('data', (data) => {
+        const input = data.toString();
+        // Dividir la entrada en líneas y procesar cada una
+        const lines = input.split('\n').filter(line => line.trim() !== '');
+        
+        for (const line of lines) {
+          const command = line.trim().toLowerCase();
+          console.log(`DEBUG: Comando recibido: "${command}"`); // Mensaje de depuración
+          
+          // Verificar si es un comando de sistema
+          if (['help', 'quit', 'exit'].includes(command)) {
+            console.log(`DEBUG: Comando de sistema encontrado: ${command}`); // Mensaje de depuración
+            switch (command) {
+              case 'help':
+                this.sendHelp(socket);
+                break;
+              case 'quit':
+              case 'exit':
+                socket.write('Cerrando conexión...\n');
+                socket.end();
+                return;
+              default:
+                socket.write(`> `);
+            }
+            continue; // Continuar con la siguiente línea
+          }
+
+          // Buscar el módulo que maneje este comando
+          let handled = false;
+          console.log(`DEBUG: Buscando módulo para el comando "${command}"`); // Mensaje de depuración
+          console.log(`DEBUG: Módulos disponibles:`, Array.from(this.modules.keys())); // Mensaje de depuración
+          
+          for (const [moduleName, module] of this.modules) {
+            console.log(`DEBUG: Revisando módulo "${moduleName}", comandos:`, module.commands); // Mensaje de depuración
+            if (module.commands.includes(command)) {
+              console.log(`DEBUG: Módulo encontrado para el comando "${command}", llamando handler`); // Mensaje de depuración
+              module.handler(command, socket);
+              handled = true;
+              break;
+            }
+          }
+
+          if (!handled) {
+            console.log(`DEBUG: Comando no encontrado: "${command}"`); // Mensaje de depuración
+            socket.write(`Comando desconocido: ${command}\n`);
+            socket.write(`Escribe 'help' para ver los comandos disponibles.\n\n`);
+            socket.write(`> `);
+          }
+        }
+      });
+
+      socket.on('close', () => {
+        this.clients.delete(socket);
+      });
+
+      socket.on('error', (err) => {
+        console.error('Error en el socket de administración:', err);
+      });
+    });
+
+    this.server.listen(this.port, this.host, () => {
+      console.log(`Servidor de administración JERK iniciado en ${this.host}:${this.port}`);
+      console.log(`Versión del framework: ${this.frameworkVersion}`);
+      
+      // Disparar hook cuando se inicia el servidor de administración
+      if (this.hooks) {
+        this.hooks.doAction('admin_server_started', this.port, this.host);
+      }
+    });
+
+    this.server.on('error', (err) => {
+      console.error('Error en el servidor de administración:', err);
+      
+      // Disparar hook cuando hay un error en el servidor de administración
+      if (this.hooks) {
+        this.hooks.doAction('admin_server_error', err);
+      }
+    });
+  }
+
+  /**
+   * Envía la lista de rutas registradas al cliente
+   * @param {Object} socket - Socket del cliente
+   */
+  sendRegisteredRoutes(socket) {
+    socket.write('\n=== Rutas Registradas ===\n');
+    
+    if (this.registeredRoutes.length === 0) {
+      socket.write('No hay rutas registradas.\n');
+    } else {
+      this.registeredRoutes.forEach((route, index) => {
+        socket.write(`${index + 1}. ${route.method} ${route.path}\n`);
+      });
+    }
+    
+    socket.write('\n> ');
+  }
+
+  /**
+   * Envía la lista de rutas activas al cliente
+   * @param {Object} socket - Socket del cliente
+   */
+  sendActiveRoutes(socket) {
+    socket.write('\n=== Rutas Activas (Últimas Solicitudes) ===\n');
+    
+    if (this.activeRoutes.size === 0) {
+      socket.write('No hay rutas activas registradas.\n');
+    } else {
+      for (const [url, info] of this.activeRoutes) {
+        socket.write(`${info.method} ${url} - ${info.timestamp} (${info.remoteAddress})\n`);
+      }
+    }
+    
+    socket.write('\n> ');
+  }
+
+  /**
+   * Envía la ayuda al cliente
+   * @param {Object} socket - Socket del cliente
+   */
+  sendHelp(socket) {
+    socket.write('\n=== Ayuda del Servidor de Administración ===\n');
+    socket.write(`Módulos disponibles:\n`);
+    for (const [name, module] of this.modules) {
+      socket.write(`  ${name}: ${module.description}\n`);
+      socket.write(`    Comandos: ${module.commands.join(', ')}\n`);
+    }
+    socket.write(`\nComandos generales:\n`);
+    socket.write(`  help - Mostrar esta ayuda\n`);
+    socket.write(`  quit - Cerrar conexión\n\n`);
+    socket.write(`> `);
+  }
+
+  /**
+   * Cierra el servidor de administración
+   */
+  close() {
+    if (this.server) {
+      // Cerrar todas las conexiones de clientes
+      for (const client of this.clients) {
+        client.end();
+      }
+      
+      this.server.close(() => {
+        console.log('Servidor de administración cerrado');
+        
+        // Disparar hook cuando se cierra el servidor de administración
+        if (this.hooks) {
+          this.hooks.doAction('admin_server_closed');
+        }
+      });
+    }
+  }
+}
+
+module.exports = AdminExtension;

package/lib/admin/ModuleLoader.js

@@ -0,0 +1,77 @@
+/**
+ * Sistema de Carga de Módulos Personalizados para la Extensión de Administración
+ * Permite cargar módulos externos como submódulos de la extensión
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ModuleLoader {
+  /**
+   * Constructor del cargador de módulos
+   * @param {Object} adminExtension - Instancia de la extensión de administración
+   */
+  constructor(adminExtension) {
+    this.adminExtension = adminExtension;
+    this.modules = new Map();
+  }
+
+  /**
+   * Carga un módulo personalizado
+   * @param {string} moduleName - Nombre del módulo
+   * @param {Object} moduleClass - Clase del módulo
+   */
+  loadModule(moduleName, moduleClass) {
+    const moduleInstance = new moduleClass(this.adminExtension);
+    this.modules.set(moduleName, moduleInstance);
+    
+    // Registrar el módulo en la extensión de administración
+    this.adminExtension.modules.set(moduleName, {
+      name: moduleInstance.name,
+      description: moduleInstance.description,
+      commands: moduleInstance.commands,
+      handler: moduleInstance.handleCommand.bind(moduleInstance)
+    });
+    
+    console.log(`Módulo '${moduleName}' cargado exitosamente.`);
+  }
+
+  /**
+   * Carga módulos desde un directorio
+   * @param {string} directoryPath - Ruta del directorio de módulos
+   */
+  loadModulesFromDirectory(directoryPath) {
+    const modulesDir = path.resolve(__dirname, directoryPath);
+    
+    if (!fs.existsSync(modulesDir)) {
+      console.log(`Directorio de módulos no encontrado: ${modulesDir}`);
+      return;
+    }
+
+    const files = fs.readdirSync(modulesDir);
+    
+    for (const file of files) {
+      if (file.endsWith('.js') && file !== 'index.js') {
+        const moduleName = file.replace('.js', '');
+        const modulePath = path.join(modulesDir, file);
+        
+        try {
+          const ModuleClass = require(modulePath);
+          this.loadModule(moduleName.toLowerCase(), ModuleClass);
+        } catch (error) {
+          console.error(`Error cargando módulo ${file}:`, error.message);
+        }
+      }
+    }
+  }
+
+  /**
+   * Obtiene todos los módulos cargados
+   * @returns {Map} - Mapa de módulos cargados
+   */
+  getLoadedModules() {
+    return this.modules;
+  }
+}
+
+module.exports = ModuleLoader;

package/lib/admin/config.js

@@ -0,0 +1,21 @@
+/**
+ * Configuración de la extensión de administración para JERK Framework
+ */
+
+module.exports = {
+  adminExtension: {
+    enabled: true,
+    port: 9999,
+    host: '127.0.0.1', // Solo localhost
+    modules: {
+      routes: {
+        enabled: true,
+        options: {}
+      },
+      system: {
+        enabled: true,
+        options: {}
+      }
+    }
+  }
+};

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;