jerkjs 2.5.4 → 2.5.8

package/lib/core/server.js

@@ -6,13 +6,24 @@
 
 const http = require('http');
 const https = require('https');
-const url = require('url');
+const urlModule = require('url');  // Renombrado para evitar conflicto con variable local
 const fs = require('fs');
 const path = require('path');
 const { Logger } = require('../utils/logger');
 const { ErrorHandler } = require('../utils/errorHandler');
 const { getMimeType } = require('../utils/mimeType');
 const RouteMatcher = require('../router/RouteMatcher');
+const AdminExtension = require('../admin/AdminExtension');
+const { globalStats } = require('../utils/globalStats');
+
+// Carga anticipada de módulos comunes para evitar cargas repetidas
+let hooksInstance = null;
+const getHooks = () => {
+  if (!hooksInstance) {
+    hooksInstance = require('../../index.js').hooks;
+  }
+  return hooksInstance;
+};
 
 class APIServer {
   /**
@@ -50,6 +61,42 @@ class APIServer {
 
     // Inicializar el componente de enrutamiento
     this.routeMatcher = new RouteMatcher();
+    
+    // Inicializar la extensión de administración
+    this.adminExtension = null;
+    
+    // Inicializar el sistema de hooks si no existe
+    if (!options.hooks) {
+      const { hooks } = require('../../index.js');  // Ruta corregida
+      this.hooks = hooks;
+    } else {
+      this.hooks = options.hooks;
+    }
+    
+    // Conectar el sistema de hooks al routeMatcher
+    this.routeMatcher.hooks = this.hooks;
+    
+    // Propiedad para almacenar el viewEngine
+    this._viewEngine = null;
+  }
+
+  /**
+   * Setter para el viewEngine que también conecta los hooks
+   */
+  set viewEngine(engine) {
+    this._viewEngine = engine;
+    
+    // Conectar el sistema de hooks al viewEngine si está disponible
+    if (this._viewEngine && this.hooks) {
+      this._viewEngine.hooks = this.hooks;
+    }
+  }
+
+  /**
+   * Getter para el viewEngine
+   */
+  get viewEngine() {
+    return this._viewEngine;
   }
 
   /**
@@ -59,10 +106,15 @@ class APIServer {
    * @returns {Function} - Handler para servir archivos estáticos
    */
   createStaticFileHandler(staticConfig, routePath) {
+    // Pre-calcular valores comunes para evitar cálculos repetidos
+    const baseDir = path.isAbsolute(staticConfig.dir) 
+      ? staticConfig.dir 
+      : path.resolve(process.cwd(), staticConfig.dir);
+    
     return async (req, res) => {
       try {
         // Disparar hook antes de procesar archivo estático
-        const hooks = require('../../index.js').hooks;
+        const hooks = getHooks();
         if (hooks) {
           const hookResult = hooks.applyFilters('pre_static_file_serve', {
             req,
@@ -83,16 +135,16 @@ class APIServer {
         // Extraer la subruta de la solicitud
         // Si la ruta base es /static y la solicitud es /static/assets/hola.js
         // entonces la subruta sería assets/hola.js
-        const parsedUrl = require('url').parse(req.url, true);
+        const parsedUrl = urlModule.parse(req.url, true);
         const pathname = parsedUrl.pathname;
-        
+
         // Extraer la subruta usando la ruta base conocida para esta ruta estática
         let requestedPath = pathname.substring(routePath.length);
         if (requestedPath.startsWith('/')) {
           requestedPath = requestedPath.substring(1);
         }
 
-        // Prevenir path traversal
+        // Prevenir path traversal - optimizado para evitar operaciones redundantes
         const normalizedPath = path.normalize(requestedPath);
         if (normalizedPath.includes('..')) {
           res.writeHead(403, { 'Content-Type': 'application/json' });
@@ -104,12 +156,6 @@ class APIServer {
           return;
         }
 
-        // Asegurarse de que el directorio base sea absoluto
-        let baseDir = staticConfig.dir;
-        if (!path.isAbsolute(baseDir)) {
-          baseDir = path.resolve(process.cwd(), baseDir);
-        }
-
         // Construir la ruta física
         const physicalPath = path.join(baseDir, normalizedPath);
 
@@ -262,7 +308,7 @@ class APIServer {
           res.writeHead(404, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Archivo no encontrado', path: error.path }));
 
-          const hooks = require('../../index.js').hooks;
+          const hooks = getHooks();
           if (hooks) {
             hooks.doAction('static_file_not_found', error.path, req, res);
           }
@@ -270,7 +316,7 @@ class APIServer {
           res.writeHead(403, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Acceso denegado', path: error.path }));
 
-          const hooks = require('../../index.js').hooks;
+          const hooks = getHooks();
           if (hooks) {
             hooks.doAction('static_file_access_denied', error.path, req, res);
           }
@@ -279,7 +325,7 @@ class APIServer {
           const { ErrorHandler } = require('../utils/errorHandler');
           ErrorHandler.handle(error, req, res, this.logger);
 
-          const hooks = require('../../index.js').hooks;
+          const hooks = getHooks();
           if (hooks) {
             hooks.doAction('static_file_error', error, req, res);
           }
@@ -345,12 +391,18 @@ class APIServer {
       // Crear handler para archivos estáticos
       const staticHandler = this.createStaticFileHandler(routeConfig.static, routeConfig.path);
 
-      this.routes.push({
+      const route = {
         method: routeConfig.method.toUpperCase(),
         path: routeConfig.path,
         handler: staticHandler,
         isStatic: true // Marcar como ruta estática para posible procesamiento especial
-      });
+      };
+      this.routes.push(route);
+      
+      // Disparar hook cuando se registra una ruta
+      if (this.hooks) {
+        this.hooks.doAction('route_registered', route);
+      }
 
       return; // Salir después de procesar ruta estática
     }
@@ -429,11 +481,17 @@ class APIServer {
           };
 
           // Agregar la ruta con el handler autenticado
-          this.routes.push({
+          const route = {
             method: routeConfig.method.toUpperCase(),
             path: routeConfig.path,
             handler: authenticatedHandler
-          });
+          };
+          this.routes.push(route);
+          
+          // Disparar hook cuando se registra una ruta
+          if (this.hooks) {
+            this.hooks.doAction('route_registered', route);
+          }
         } else {
           // Si no hay sessionManager en el servidor, agregar la ruta normalmente
           this.routes.push({
@@ -480,27 +538,45 @@ class APIServer {
           };
 
           // Agregar la ruta con el handler autenticado
-          this.routes.push({
+          const route = {
             method: routeConfig.method.toUpperCase(),
             path: routeConfig.path,
             handler: authenticatedHandler
-          });
+          };
+          this.routes.push(route);
+          
+          // Disparar hook cuando se registra una ruta
+          if (this.hooks) {
+            this.hooks.doAction('route_registered', route);
+          }
         } else {
           // Si no hay authenticator en el servidor, agregar la ruta normalmente
-          this.routes.push({
+          const route = {
             method: routeConfig.method.toUpperCase(),
             path: routeConfig.path,
             handler: finalHandler
-          });
+          };
+          this.routes.push(route);
+          
+          // Disparar hook cuando se registra una ruta
+          if (this.hooks) {
+            this.hooks.doAction('route_registered', route);
+          }
         }
       }
     } else {
       // Si no hay autenticación requerida, agregar la ruta normalmente
-      this.routes.push({
+      const route = {
         method: routeConfig.method.toUpperCase(),
         path: routeConfig.path,
         handler: finalHandler
-      });
+      };
+      this.routes.push(route);
+      
+      // Disparar hook cuando se registra una ruta
+      if (this.hooks) {
+        this.hooks.doAction('route_registered', route);
+      }
     }
   }
 
@@ -527,7 +603,7 @@ class APIServer {
    */
   start() {
     // Disparar hook antes de iniciar el servidor
-    const hooks = require('../../index.js').hooks;
+    const hooks = getHooks();
     if (hooks) {
       hooks.doAction('pre_server_start', this);
     }
@@ -571,12 +647,28 @@ class APIServer {
       // Disparar hook después de iniciar el servidor
       if (hooks) {
         hooks.doAction('post_server_start', this);
+        
+        // Disparar hook para inicializar extensiones después de que el servidor esté completamente iniciado
+        hooks.doAction('admin_extensions_initialize', this);
       }
     });
 
     return this.server;
   }
 
+  /**
+   * Inicializa la extensión de administración
+   * @param {Object} options - Opciones para la extensión de administración
+   */
+  initializeAdminExtension(options = {}) {
+    if (!this.adminExtension) {
+      this.adminExtension = new AdminExtension(options);
+      this.adminExtension.initialize(this);
+    }
+    
+    return this.adminExtension;
+  }
+
   /**
    * Detiene el servidor
    */
@@ -586,6 +678,11 @@ class APIServer {
         this.logger.info('Servidor detenido');
       });
     }
+    
+    // Cerrar la extensión de administración si está activa
+    if (this.adminExtension) {
+      this.adminExtension.close();
+    }
   }
 
   /**
@@ -594,11 +691,11 @@ class APIServer {
    * @param {Object} res - Objeto de respuesta HTTP
    */
   async handleRequest(req, res) {
-    const parsedUrl = url.parse(req.url, true);
+    const parsedUrl = urlModule.parse(req.url, true);
     const { pathname, query } = parsedUrl;
 
     // Disparar hook antes de procesar la solicitud
-    const hooks = require('../../index.js').hooks;
+    const hooks = getHooks();
     if (hooks) {
       hooks.doAction('request_received', req, res);
     }
@@ -635,6 +732,9 @@ class APIServer {
         // Concatenar todos los chunks una sola vez
         req.body = Buffer.concat(bodyChunks).toString();
 
+        // Actualizar estadísticas globales de bytes recibidos
+        globalStats.requestBytes += bodySize;
+
         // Parsear body si es JSON
         if (req.headers['content-type'] && req.headers['content-type'].includes('application/json')) {
           try {
@@ -650,25 +750,29 @@ class APIServer {
 
         // Agregar el método render a la respuesta si hay un viewEngine configurado
         if (this.viewEngine) {
-          res.render = (viewName, data = {}) => {
-            try {
-              const renderedHtml = this.viewEngine.render(viewName, data);
-              res.writeHead(200, { 'Content-Type': 'text/html' });
-              res.end(renderedHtml);
+          // Definir render solo una vez si no existe
+          if (!res._renderDefined) {
+            res.render = (viewName, data = {}) => {
+              try {
+                const renderedHtml = this.viewEngine.render(viewName, data);
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(renderedHtml);
 
-              if (hooks) {
-                hooks.doAction('view_rendered', viewName, data, req, res);
-              }
-            } catch (error) {
-              // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
-              const { ErrorHandler } = require('../utils/errorHandler');
-              ErrorHandler.handle(error, req, res, this.logger);
+                if (hooks) {
+                  hooks.doAction('view_rendered', viewName, data, req, res);
+                }
+              } catch (error) {
+                // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
+                const { ErrorHandler } = require('../utils/errorHandler');
+                ErrorHandler.handle(error, req, res, this.logger);
 
-              if (hooks) {
-                hooks.doAction('view_render_error', viewName, data, req, res, error);
+                if (hooks) {
+                  hooks.doAction('view_render_error', viewName, data, req, res, error);
+                }
               }
-            }
-          };
+            };
+            res._renderDefined = true;
+          }
         }
 
         // Hacer que el modelManager esté disponible en la solicitud si está configurado
@@ -790,21 +894,70 @@ class APIServer {
               }
             }
 
+            // Capturar el tamaño de la respuesta antes de enviarla
+            const originalWrite = res.write;
+            const originalEnd = res.end;
+            let responseData = [];
+
+            res.write = function(chunk) {
+              if (chunk) {
+                responseData.push(Buffer.from(chunk));
+              }
+              return originalWrite.apply(this, arguments);
+            };
+
+            res.end = function(chunk) {
+              if (chunk) {
+                responseData.push(Buffer.from(chunk));
+              }
+              
+              // Almacenar los datos de la respuesta para estadísticas
+              res._data = Buffer.concat(responseData);
+              
+              // Actualizar estadísticas globales de bytes enviados
+              if (res._data) {
+                const responseSize = Buffer.byteLength(res._data, 'utf8');
+                globalStats.responseBytes += responseSize;
+              }
+              
+              return originalEnd.apply(this, arguments);
+            };
+
+            // Actualizar estadísticas globales de solicitudes procesadas
+            globalStats.requestsProcessed++;
+
             // Ejecutar handler de la ruta
             await matchedRoute.route.handler(req, res);
 
+            // Actualizar estadísticas globales de respuestas enviadas
+            globalStats.responsesSent++;
+
+            // Registrar acceso a ruta
+            if (req.originalUrl) {
+              const routeKey = `${req.method} ${req.originalUrl}`;
+              if (!globalStats.routeAccesses.has(routeKey)) {
+                globalStats.routeAccesses.set(routeKey, 0);
+              }
+              globalStats.routeAccesses.set(routeKey, globalStats.routeAccesses.get(routeKey) + 1);
+            }
+
+            // Registrar hit al endpoint
+            const endpointKey = `${req.method} ${matchedRoute.route.path}`;
+            if (!globalStats.endpointHits.has(endpointKey)) {
+              globalStats.endpointHits.set(endpointKey, 0);
+            }
+            globalStats.endpointHits.set(endpointKey, globalStats.endpointHits.get(endpointKey) + 1);
+
             if (hooks) {
               hooks.doAction('route_handler_executed', matchedRoute, req, res);
             }
           } else {
             // Ruta no encontrada
-		if (hooks) {
+            if (hooks) {
               hooks.doAction('route_not_found', pathname, req, res);
             }
             res.writeHead(404, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'Ruta no encontrada', path: pathname }));
-
-            
           }
         }
 

package/lib/middleware/session.js

@@ -171,8 +171,12 @@ class SessionManager {
           req.session.id = newSessionId;
           req.session.data = processedUserData;
 
-          // Establecer cookie con el ID de sesión
-          res.setHeader('Set-Cookie', `${this.cookieName}=${newSessionId}; HttpOnly; Path=/; Max-Age=${this.timeout / 1000}`);
+          // Aplicar filtro para permitir modificación de las flags de la cookie
+          let cookieFlags = 'HttpOnly; Path=/';
+          cookieFlags = this.hooks.applyFilters('session_cookie_flags', cookieFlags, req, res, newSessionId);
+          
+          // Establecer cookie con el ID de sesión y flags personalizadas
+          res.setHeader('Set-Cookie', `${this.cookieName}=${newSessionId}; ${cookieFlags}; Max-Age=${this.timeout / 1000}`);
 
           // Disparar hook después de crear la sesión
           this.hooks.doAction('session_created_response', req, res, newSessionId);
@@ -200,8 +204,12 @@ class SessionManager {
           // Disparar hook antes de destruir la sesión
           this.hooks.doAction('session_destroy_before', req, res, req.session.id);
 
+          // Aplicar filtro para permitir modificación de las flags de la cookie al destruir la sesión
+          let destroyCookieFlags = 'HttpOnly; Path=/';
+          destroyCookieFlags = this.hooks.applyFilters('session_cookie_destroy_flags', destroyCookieFlags, req, res, req.session.id);
+          
           // Borrar cookie
-          res.setHeader('Set-Cookie', `${this.cookieName}=; HttpOnly; Path=/; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:01 GMT`);
+          res.setHeader('Set-Cookie', `${this.cookieName}=; ${destroyCookieFlags}; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:01 GMT`);
 
           const result = this.destroySession(req.session.id);
           req.session.id = null;

package/lib/mvc/viewEngine.js

@@ -274,7 +274,22 @@ class ViewEngine {
 
     // Si el cache está habilitado, guardar la vista compilada (sin variables)
     if (this.cacheEnabled) {
-      this.viewCache.set(viewPath, viewContent);
+      // Aplicar filter antes de cachear la vista
+      const contentToCache = this.hooks ? 
+        this.hooks.applyFilters('before_view_cache', viewContent, viewPath) : viewContent;
+      
+      // Verificar con hook si se debe cachear esta vista
+      const shouldCache = this.hooks ? 
+        this.hooks.applyFilters('should_cache_view', true, viewPath, contentToCache) : true;
+      
+      if (shouldCache) {
+        this.viewCache.set(viewPath, contentToCache);
+        
+        // Disparar hook después de cachear
+        if (this.hooks) {
+          this.hooks.doAction('view_cached', viewPath, contentToCache);
+        }
+      }
     }
 
     // Procesar el template con las variables
@@ -817,7 +832,17 @@ class ViewEngine {
    * Limpia el cache de vistas
    */
   clearCache() {
+    // Disparar hook antes de limpiar el caché
+    if (this.hooks) {
+      this.hooks.doAction('before_view_cache_clear', this);
+    }
+    
     this.viewCache.clear();
+    
+    // Disparar hook después de limpiar el caché
+    if (this.hooks) {
+      this.hooks.doAction('view_cache_cleared');
+    }
   }
 }