jerkjs 2.5.6 → 2.6.1

package/lib/core/server.js

@@ -13,9 +13,12 @@ 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;
+let errorHandlerInstance = null;
 const getHooks = () => {
   if (!hooksInstance) {
     hooksInstance = require('../../index.js').hooks;
@@ -23,6 +26,13 @@ const getHooks = () => {
   return hooksInstance;
 };
 
+const getErrorHandler = () => {
+  if (!errorHandlerInstance) {
+    errorHandlerInstance = require('../utils/errorHandler');
+  }
+  return errorHandlerInstance;
+};
+
 class APIServer {
   /**
    * Constructor del servidor
@@ -59,6 +69,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;
   }
 
   /**
@@ -76,7 +122,8 @@ class APIServer {
     return async (req, res) => {
       try {
         // Disparar hook antes de procesar archivo estático
-        const hooks = getHooks();
+        // Usar la instancia de hooks del servidor para evitar llamadas repetidas a getHooks()
+        const hooks = this.hooks;
         if (hooks) {
           const hookResult = hooks.applyFilters('pre_static_file_serve', {
             req,
@@ -112,8 +159,8 @@ class APIServer {
           res.writeHead(403, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Acceso denegado' }));
 
-          if (hooks) {
-            hooks.doAction('static_file_access_denied', req, res, normalizedPath);
+          if (this.hooks) {
+            this.hooks.doAction('static_file_access_denied', req, res, normalizedPath);
           }
           return;
         }
@@ -139,8 +186,8 @@ class APIServer {
                 try {
                   await fs.promises.access(indexPath);
                   // Disparar hook antes de servir archivo índice
-                  if (hooks) {
-                    hooks.doAction('serving_index_file', indexPath, req, res);
+                  if (this.hooks) {
+                    this.hooks.doAction('serving_index_file', indexPath, req, res);
                   }
 
                   const fileContent = await fs.promises.readFile(indexPath);
@@ -156,8 +203,8 @@ class APIServer {
                   res.end(fileContent);
 
                   // Disparar hook después de servir archivo
-                  if (hooks) {
-                    hooks.doAction('static_file_served', indexPath, req, res);
+                  if (this.hooks) {
+                    this.hooks.doAction('static_file_served', indexPath, req, res);
                   }
                   return;
                 } catch (e) {
@@ -169,8 +216,8 @@ class APIServer {
               res.writeHead(404, { 'Content-Type': 'application/json' });
               res.end(JSON.stringify({ error: 'Directorio no encontrado', path: dirPath }));
 
-              if (hooks) {
-                hooks.doAction('static_directory_no_index', dirPath, req, res);
+              if (this.hooks) {
+                this.hooks.doAction('static_directory_no_index', dirPath, req, res);
               }
               return;
             } else {
@@ -178,8 +225,8 @@ class APIServer {
               res.writeHead(404, { 'Content-Type': 'application/json' });
               res.end(JSON.stringify({ error: 'Archivo no encontrado', path: physicalPath }));
 
-              if (hooks) {
-                hooks.doAction('static_file_not_found', physicalPath, req, res);
+              if (this.hooks) {
+                this.hooks.doAction('static_file_not_found', physicalPath, req, res);
               }
               return;
             }
@@ -188,8 +235,8 @@ class APIServer {
             res.writeHead(404, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'Archivo no encontrado', path: physicalPath }));
 
-            if (hooks) {
-              hooks.doAction('static_file_not_found', physicalPath, req, res);
+            if (this.hooks) {
+              this.hooks.doAction('static_file_not_found', physicalPath, req, res);
             }
             return;
           }
@@ -204,8 +251,8 @@ class APIServer {
             try {
               await fs.promises.access(indexPath);
               // Disparar hook antes de servir archivo índice
-              if (hooks) {
-                hooks.doAction('serving_index_file', indexPath, req, res);
+              if (this.hooks) {
+                this.hooks.doAction('serving_index_file', indexPath, req, res);
               }
 
               const fileContent = await fs.promises.readFile(indexPath);
@@ -221,8 +268,8 @@ class APIServer {
               res.end(fileContent);
 
               // Disparar hook después de servir archivo
-              if (hooks) {
-                hooks.doAction('static_file_served', indexPath, req, res);
+              if (this.hooks) {
+                this.hooks.doAction('static_file_served', indexPath, req, res);
               }
               return;
             } catch (e) {
@@ -234,15 +281,15 @@ class APIServer {
           res.writeHead(404, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Directorio no encontrado' }));
 
-          if (hooks) {
-            hooks.doAction('static_directory_no_index', dirPath, req, res);
+          if (this.hooks) {
+            this.hooks.doAction('static_directory_no_index', dirPath, req, res);
           }
           return;
         }
 
         // Disparar hook antes de leer archivo
-        if (hooks) {
-          hooks.doAction('before_reading_static_file', physicalPath, req, res);
+        if (this.hooks) {
+          this.hooks.doAction('before_reading_static_file', physicalPath, req, res);
         }
 
         // Leer y servir el archivo
@@ -262,34 +309,31 @@ class APIServer {
         res.end(fileContent);
 
         // Disparar hook después de servir archivo
-        if (hooks) {
-          hooks.doAction('static_file_served', physicalPath, req, res);
+        if (this.hooks) {
+          this.hooks.doAction('static_file_served', physicalPath, req, res);
         }
       } catch (error) {
         if (error.code === 'ENOENT') {
           res.writeHead(404, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Archivo no encontrado', path: error.path }));
 
-          const hooks = getHooks();
-          if (hooks) {
-            hooks.doAction('static_file_not_found', error.path, req, res);
+          if (this.hooks) {
+            this.hooks.doAction('static_file_not_found', error.path, req, res);
           }
         } else if (error.code === 'EACCES') {
           res.writeHead(403, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Acceso denegado', path: error.path }));
 
-          const hooks = getHooks();
-          if (hooks) {
-            hooks.doAction('static_file_access_denied', error.path, req, res);
+          if (this.hooks) {
+            this.hooks.doAction('static_file_access_denied', error.path, req, res);
           }
         } else {
           // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
-          const { ErrorHandler } = require('../utils/errorHandler');
+          const { ErrorHandler } = getErrorHandler();
           ErrorHandler.handle(error, req, res, this.logger);
 
-          const hooks = getHooks();
-          if (hooks) {
-            hooks.doAction('static_file_error', error, req, res);
+          if (this.hooks) {
+            this.hooks.doAction('static_file_error', error, req, res);
           }
         }
       }
@@ -353,12 +397,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
     }
@@ -369,7 +419,6 @@ class APIServer {
 
     // Obtener el handler final según las configuraciones
     let finalHandler = routeConfig.handler;
-    const path = require('path');
 
     // Si se especifica un controlador, cargarlo y obtener el handler
     if (routeConfig.controller && routeConfig.handlerName) {
@@ -401,7 +450,6 @@ class APIServer {
       if (routeConfig.auth === 'session') {
         // Verificar si el servidor tiene sessionManager
         if (this.sessionManager) {
-          const { sessionAuth } = require('../middleware/session');
           const authMiddleware = sessionAuth(this.sessionManager, routeConfig.authOptions || {});
 
           // Crear un nuevo handler que ejecute la autenticación primero
@@ -429,7 +477,7 @@ class APIServer {
               }
             } catch (error) {
               // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
-              const { ErrorHandler } = require('../utils/errorHandler');
+              const { ErrorHandler } = getErrorHandler();
               if (!res.headersSent) {
                 ErrorHandler.handle(error, req, res, this.logger);
               }
@@ -437,11 +485,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,7 +534,7 @@ class APIServer {
               }
             } catch (error) {
               // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
-              const { ErrorHandler } = require('../utils/errorHandler');
+              const { ErrorHandler } = getErrorHandler();
               if (!res.headersSent) {
                 ErrorHandler.handle(error, req, res, this.logger);
               }
@@ -488,27 +542,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);
+      }
     }
   }
 
@@ -535,9 +607,8 @@ class APIServer {
    */
   start() {
     // Disparar hook antes de iniciar el servidor
-    const hooks = getHooks();
-    if (hooks) {
-      hooks.doAction('pre_server_start', this);
+    if (this.hooks) {
+      this.hooks.doAction('pre_server_start', this);
     }
 
     if (this.https && Object.keys(this.httpsOptions).length > 0) {
@@ -577,14 +648,30 @@ class APIServer {
       this.logger.logMemoryUsage();
 
       // Disparar hook después de iniciar el servidor
-      if (hooks) {
-        hooks.doAction('post_server_start', this);
+      if (this.hooks) {
+        this.hooks.doAction('post_server_start', this);
+
+        // Disparar hook para inicializar extensiones después de que el servidor esté completamente iniciado
+        this.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
    */
@@ -594,6 +681,11 @@ class APIServer {
         this.logger.info('Servidor detenido');
       });
     }
+    
+    // Cerrar la extensión de administración si está activa
+    if (this.adminExtension) {
+      this.adminExtension.close();
+    }
   }
 
   /**
@@ -606,9 +698,8 @@ class APIServer {
     const { pathname, query } = parsedUrl;
 
     // Disparar hook antes de procesar la solicitud
-    const hooks = getHooks();
-    if (hooks) {
-      hooks.doAction('request_received', req, res);
+    if (this.hooks) {
+      this.hooks.doAction('request_received', req, res);
     }
 
     // Agregar propiedades útiles a la solicitud
@@ -643,6 +734,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 {
@@ -666,16 +760,16 @@ class APIServer {
                 res.writeHead(200, { 'Content-Type': 'text/html' });
                 res.end(renderedHtml);
 
-                if (hooks) {
-                  hooks.doAction('view_rendered', viewName, data, req, res);
+                if (this.hooks) {
+                  this.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 (this.hooks) {
+                  this.hooks.doAction('view_render_error', viewName, data, req, res, error);
                 }
               }
             };
@@ -718,8 +812,8 @@ class APIServer {
               }
 
               if (res.finished) {
-                if (hooks) {
-                  hooks.doAction('middleware_response_finished', req, res);
+                if (this.hooks) {
+                  this.hooks.doAction('middleware_response_finished', req, res);
                 }
                 return; // Si el middleware respondió, salir
               }
@@ -733,8 +827,8 @@ class APIServer {
             // Agregar parámetros a la solicitud
             req.params = matchedRoute.params;
 
-            if (hooks) {
-              hooks.doAction('route_matched', matchedRoute, req, res);
+            if (this.hooks) {
+              this.hooks.doAction('route_matched', matchedRoute, req, res);
             }
 
             // Ejecutar handler de la ruta
@@ -748,8 +842,8 @@ class APIServer {
               res.writeHead(204);
               res.end();
 
-              if (hooks) {
-                hooks.doAction('options_response_sent', req, res);
+              if (this.hooks) {
+                this.hooks.doAction('options_response_sent', req, res);
               }
             }
           }
@@ -761,8 +855,8 @@ class APIServer {
             // Agregar parámetros a la solicitud
             req.params = matchedRoute.params;
 
-            if (hooks) {
-              hooks.doAction('route_matched', matchedRoute, req, res);
+            if (this.hooks) {
+              this.hooks.doAction('route_matched', matchedRoute, req, res);
             }
 
             // Ejecutar middlewares (excepto para rutas estáticas)
@@ -793,8 +887,8 @@ class APIServer {
                   }
 
                   if (res.finished) {
-                    if (hooks) {
-                      hooks.doAction('middleware_response_finished', req, res);
+                    if (this.hooks) {
+                      this.hooks.doAction('middleware_response_finished', req, res);
                     }
                     return; // Si el middleware respondió, salir
                   }
@@ -802,30 +896,82 @@ 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);
 
-            if (hooks) {
-              hooks.doAction('route_handler_executed', matchedRoute, 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 (this.hooks) {
+              this.hooks.doAction('route_handler_executed', matchedRoute, req, res);
             }
           } else {
             // Ruta no encontrada
-            if (hooks) {
-              hooks.doAction('route_not_found', pathname, req, res);
+            if (this.hooks) {
+              this.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 }));
           }
         }
 
-        if (hooks) {
-          hooks.doAction('request_processed', req, res);
+        if (this.hooks) {
+          this.hooks.doAction('request_processed', req, res);
         }
       } catch (error) {
-        if (hooks) {
-          hooks.doAction('request_error', req, res, error);
+        if (this.hooks) {
+          this.hooks.doAction('request_error', req, res, error);
         }
 
+        const { ErrorHandler } = getErrorHandler();
         ErrorHandler.handle(error, req, res, this.logger);
       }
     });