jerkjs 2.1.6 → 2.2.0

package/lib/core/server.js

@@ -1,15 +1,17 @@
 /**
  * Servidor HTTP básico para el framework JERK
  * Implementación del componente core/server.js
- * JERK Framework v2.1 - Con optimizaciones de rendimiento
+ * JERK Framework v2.1 - Con optimizaciones de rendimiento y soporte para archivos estáticos
  */
 
 const http = require('http');
 const https = require('https');
 const url = require('url');
 const fs = require('fs');
+const path = require('path');
 const { Logger } = require('../utils/logger');
 const { ErrorHandler } = require('../utils/errorHandler');
+const { getMimeType } = require('../utils/mimeType');
 
 class APIServer {
   /**
@@ -49,6 +51,198 @@ class APIServer {
     this.routeRegexCache = new Map();
   }
 
+  /**
+   * Método para crear un handler para servir archivos estáticos
+   * @param {Object} staticConfig - Configuración de la ruta estática
+   * @returns {Function} - Handler para servir archivos estáticos
+   */
+  createStaticFileHandler(staticConfig) {
+    return async (req, res) => {
+      try {
+        // Disparar hook antes de procesar archivo estático
+        const hooks = require('../../index.js').hooks;
+        if (hooks) {
+          const hookResult = hooks.applyFilters('pre_static_file_serve', {
+            req,
+            res,
+            staticConfig,
+            shouldContinue: true
+          });
+
+          if (!hookResult.shouldContinue) {
+            return; // Cancelar proceso si el filtro lo indica
+          }
+
+          // Actualizar configuración si el filtro la modificó
+          staticConfig = hookResult.staticConfig || staticConfig;
+        }
+
+        // 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 pathname = parsedUrl.pathname;
+        let requestedPath = '';
+
+        // Encontrar la ruta estática que coincide con la solicitud actual
+        for (const route of this.routes) {
+          if (route.isStatic && pathname.startsWith(route.path)) {
+            requestedPath = pathname.substring(route.path.length);
+            if (requestedPath.startsWith('/')) {
+              requestedPath = requestedPath.substring(1);
+            }
+            break;
+          }
+        }
+
+        // Prevenir path traversal
+        const normalizedPath = path.normalize(requestedPath);
+        if (normalizedPath.includes('..')) {
+          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);
+          }
+          return;
+        }
+
+        // Asegurarse de que el directorio base sea absoluto
+        let baseDir = staticConfig.dir;
+        if (!path.isAbsolute(baseDir)) {
+          baseDir = path.join(process.cwd(), baseDir);
+        }
+
+        // Construir la ruta física
+        const physicalPath = path.join(baseDir, normalizedPath);
+
+        // Verificar si el archivo existe
+        try {
+          await fs.promises.access(physicalPath);
+        } catch (accessErr) {
+          // Si no existe el archivo solicitado, verificar si es un directorio y buscar archivo índice
+          const dirPath = path.join(baseDir, normalizedPath);
+          try {
+            const stats = await fs.promises.stat(dirPath);
+
+            if (stats.isDirectory()) {
+              // Buscar archivo índice
+              for (const indexFile of staticConfig.index || ['index.html']) {
+                const indexPath = path.join(dirPath, indexFile);
+                try {
+                  await fs.promises.access(indexPath);
+                  // Disparar hook antes de servir archivo índice
+                  if (hooks) {
+                    hooks.doAction('serving_index_file', indexPath, req, res);
+                  }
+
+                  const fileContent = await fs.promises.readFile(indexPath);
+                  const mimeType = getMimeType(indexPath);
+
+                  res.setHeader('Content-Type', mimeType);
+
+                  if (staticConfig.cacheControl) {
+                    res.setHeader('Cache-Control', staticConfig.cacheControl);
+                  }
+
+                  res.writeHead(200);
+                  res.end(fileContent);
+
+                  // Disparar hook después de servir archivo
+                  if (hooks) {
+                    hooks.doAction('static_file_served', indexPath, req, res);
+                  }
+                  return;
+                } catch (e) {
+                  continue; // Probar siguiente archivo índice
+                }
+              }
+
+              // Si es directorio pero no hay archivo índice
+              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);
+              }
+              return;
+            } else {
+              // No es directorio ni archivo existente
+              res.writeHead(404, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: 'Archivo no encontrado' }));
+
+              if (hooks) {
+                hooks.doAction('static_file_not_found', physicalPath, req, res);
+              }
+              return;
+            }
+          } catch (statErr) {
+            // No es directorio ni archivo
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Archivo no encontrado' }));
+
+            if (hooks) {
+              hooks.doAction('static_file_not_found', physicalPath, req, res);
+            }
+            return;
+          }
+        }
+
+        // Disparar hook antes de leer archivo
+        if (hooks) {
+          hooks.doAction('before_reading_static_file', physicalPath, req, res);
+        }
+
+        // Leer y servir el archivo
+        const fileContent = await fs.promises.readFile(physicalPath);
+
+        // Determinar el tipo MIME
+        const mimeType = getMimeType(physicalPath);
+
+        // Configurar headers
+        res.setHeader('Content-Type', mimeType);
+
+        if (staticConfig.cacheControl) {
+          res.setHeader('Cache-Control', staticConfig.cacheControl);
+        }
+
+        res.writeHead(200);
+        res.end(fileContent);
+
+        // Disparar hook después de servir archivo
+        if (hooks) {
+          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' }));
+
+          const hooks = require('../../index.js').hooks;
+          if (hooks) {
+            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' }));
+
+          const hooks = require('../../index.js').hooks;
+          if (hooks) {
+            hooks.doAction('static_file_access_denied', error.path, req, res);
+          }
+        } else {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+
+          const hooks = require('../../index.js').hooks;
+          if (hooks) {
+            hooks.doAction('static_file_error', error, req, res);
+          }
+        }
+      }
+    };
+  }
+
   /**
    * Método para agregar una ruta al servidor
    * @param {string|Object} method - Método HTTP (GET, POST, PUT, DELETE, etc.) o un objeto de configuración de ruta
@@ -91,6 +285,31 @@ class APIServer {
       throw new Error('La ruta debe tener una propiedad "method"');
     }
 
+    // Verificar si es una ruta estática
+    if (routeConfig.static) {
+      // Validar configuración estática
+      if (!routeConfig.static.dir) {
+        throw new Error('Las rutas estáticas deben tener un directorio especificado');
+      }
+
+      // El método debe ser GET para rutas estáticas
+      if (routeConfig.method.toUpperCase() !== 'GET') {
+        throw new Error('Las rutas estáticas deben usar el método GET, no ' + routeConfig.method);
+      }
+
+      // Crear handler para archivos estáticos
+      const staticHandler = this.createStaticFileHandler(routeConfig.static);
+
+      this.routes.push({
+        method: routeConfig.method.toUpperCase(),
+        path: routeConfig.path,
+        handler: staticHandler,
+        isStatic: true // Marcar como ruta estática para posible procesamiento especial
+      });
+
+      return; // Salir después de procesar ruta estática
+    }
+
     if (!routeConfig.handler && !routeConfig.controller) {
       throw new Error('La ruta debe tener un "handler" o un "controller"');
     }
@@ -256,7 +475,7 @@ class APIServer {
    */
   findRoute(method, pathname) {
     // Buscar ruta exacta primero
-    const exactMatch = this.routes.find(route => 
+    const exactMatch = this.routes.find(route =>
       route.method === method && route.path === pathname
     );
 
@@ -267,6 +486,23 @@ class APIServer {
       };
     }
 
+    // Buscar rutas estáticas (prefijos)
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+
+      // Para rutas estáticas, verificar si la ruta solicitada comienza con el prefijo de la ruta estática
+      if (route.isStatic && pathname.startsWith(route.path)) {
+        // Verificar que sea exactamente el prefijo o que haya una barra después del prefijo
+        const remainingPath = pathname.substring(route.path.length);
+        if (route.path === '/' || remainingPath === '' || remainingPath.startsWith('/')) {
+          return {
+            route: route,
+            params: {}
+          };
+        }
+      }
+    }
+
     // Buscar rutas parametrizadas
     for (const route of this.routes) {
       if (route.method !== method) continue;
@@ -426,9 +662,16 @@ class APIServer {
     const parsedUrl = url.parse(req.url, true);
     const { pathname, query } = parsedUrl;
 
+    // Disparar hook antes de procesar la solicitud
+    const hooks = require('../../index.js').hooks;
+    if (hooks) {
+      hooks.doAction('request_received', req, res);
+    }
+
     // Agregar propiedades útiles a la solicitud
     req.query = query;
     req.params = {};
+    req.originalUrl = req.url; // Guardar la URL original para rutas estáticas
 
     // Inicializar array para acumular chunks del body
     const bodyChunks = [];
@@ -443,6 +686,10 @@ class APIServer {
         res.writeHead(413, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Solicitud demasiado grande', details: `El cuerpo de la solicitud excede el límite permitido de ${this.maxBodySize} bytes` }));
         req.destroy(); // Terminar la conexión
+
+        if (hooks) {
+          hooks.doAction('request_body_too_large', req, res, bodySize, this.maxBodySize);
+        }
         return;
       }
       bodyChunks.push(chunk);
@@ -459,6 +706,10 @@ class APIServer {
             req.body = JSON.parse(req.body);
           } catch (e) {
             req.body = {};
+
+            if (hooks) {
+              hooks.doAction('request_body_parse_error', req, res, e);
+            }
           }
         }
 
@@ -469,10 +720,18 @@ class APIServer {
               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) {
               console.error('Error renderizando vista:', error);
               res.writeHead(500, { 'Content-Type': 'application/json' });
               res.end(JSON.stringify({ error: 'Error interno del servidor', details: error.message }));
+
+              if (hooks) {
+                hooks.doAction('view_render_error', viewName, data, req, res, error);
+              }
             }
           };
         }
@@ -506,7 +765,12 @@ class APIServer {
                 await middleware(req, res);
               }
 
-              if (res.finished) return; // Si el middleware respondió, salir
+              if (res.finished) {
+                if (hooks) {
+                  hooks.doAction('middleware_response_finished', req, res);
+                }
+                return; // Si el middleware respondió, salir
+              }
             }
           }
 
@@ -516,6 +780,11 @@ class APIServer {
           if (matchedRoute) {
             // Agregar parámetros a la solicitud
             req.params = matchedRoute.params;
+
+            if (hooks) {
+              hooks.doAction('route_matched', matchedRoute, req, res);
+            }
+
             // Ejecutar handler de la ruta
             await matchedRoute.route.handler(req, res);
           } else {
@@ -526,6 +795,10 @@ class APIServer {
               // devolver 204 para cumplir con CORS preflight
               res.writeHead(204);
               res.end();
+
+              if (hooks) {
+                hooks.doAction('options_response_sent', req, res);
+              }
             }
           }
         } else {
@@ -536,45 +809,73 @@ class APIServer {
             // Agregar parámetros a la solicitud
             req.params = matchedRoute.params;
 
-            // Ejecutar middlewares
-            for (const middleware of this.middlewares) {
-              // Verificar si el middleware es una función antes de ejecutarla
-              if (typeof middleware === 'function') {
-                // Verificar si el middleware tiene firma (req, res, next)
-                if (middleware.length === 3) {
-                  // Middleware con next
-                  await new Promise((resolve, reject) => {
-                    const next = (err) => {
-                      if (err) {
-                        reject(err);
-                      } else {
-                        resolve();
+            if (hooks) {
+              hooks.doAction('route_matched', matchedRoute, req, res);
+            }
+
+            // Ejecutar middlewares (excepto para rutas estáticas)
+            if (!matchedRoute.route.isStatic) {
+              for (const middleware of this.middlewares) {
+                // Verificar si el middleware es una función antes de ejecutarla
+                if (typeof middleware === 'function') {
+                  // Verificar si el middleware tiene firma (req, res, next)
+                  if (middleware.length === 3) {
+                    // Middleware con next
+                    await new Promise((resolve, reject) => {
+                      const next = (err) => {
+                        if (err) {
+                          reject(err);
+                        } else {
+                          resolve();
+                        }
+                      };
+                      const result = middleware(req, res, next);
+                      // Si el middleware devuelve una promesa, esperarla
+                      if (result && typeof result.then === 'function') {
+                        result.then(resolve).catch(reject);
                       }
-                    };
-                    const result = middleware(req, res, next);
-                    // Si el middleware devuelve una promesa, esperarla
-                    if (result && typeof result.then === 'function') {
-                      result.then(resolve).catch(reject);
+                    });
+                  } else {
+                    // Middleware sin next
+                    await middleware(req, res);
+                  }
+
+                  if (res.finished) {
+                    if (hooks) {
+                      hooks.doAction('middleware_response_finished', req, res);
                     }
-                  });
-                } else {
-                  // Middleware sin next
-                  await middleware(req, res);
+                    return; // Si el middleware respondió, salir
+                  }
                 }
-
-                if (res.finished) return; // Si el middleware respondió, salir
               }
             }
 
             // Ejecutar handler de la ruta
             await matchedRoute.route.handler(req, res);
+
+            if (hooks) {
+              hooks.doAction('route_handler_executed', matchedRoute, req, res);
+            }
           } else {
             // Ruta no encontrada
+		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 }));
+
+            
           }
         }
+
+        if (hooks) {
+          hooks.doAction('request_processed', req, res);
+        }
       } catch (error) {
+        if (hooks) {
+          hooks.doAction('request_error', req, res, error);
+        }
+
         ErrorHandler.handle(error, req, res, this.logger);
       }
     });