jerkjs 2.0.2 → 2.1.0

package/examples/hooks/app.js

@@ -0,0 +1,136 @@
+/**
+ * Aplicación de ejemplo usando el framework JERK
+ * Demostrando routes.json, controladores y sistema de hooks
+ */
+
+const jerk = require('jerkjs');
+const {
+  APIServer,
+  Logger,
+  RouteLoader,
+  hooks
+} = jerk;
+
+// Crear instancia del logger
+const logger = new Logger({ level: 'info' });
+
+// Array para almacenar los controladores disponibles
+let availableControllers = [];
+
+// Hook que se ejecuta cuando se carga un controlador
+hooks.addAction('post_controller_load', (controllerModule, absolutePath) => {
+  logger.info(`[[HOOK]] - Controlador cargado: ${absolutePath}`);
+
+  // Extraer información sobre las funciones disponibles en el controlador
+  const controllerName = absolutePath.split('/').pop().replace('.js', '');
+
+  // Verificar si es un objeto con métodos o una instancia
+  let handlerNames = [];
+  if (typeof controllerModule === 'object') {
+    // Si es un objeto (como una instancia de ControllerBase), obtener sus métodos
+    handlerNames = Object.getOwnPropertyNames(Object.getPrototypeOf(controllerModule))
+      .filter(prop => typeof controllerModule[prop] === 'function' && prop !== 'constructor');
+  } else if (typeof controllerModule === 'function') {
+    // Si es una clase, instanciarla y obtener sus métodos
+    const instance = new controllerModule();
+    handlerNames = Object.getOwnPropertyNames(Object.getPrototypeOf(instance))
+      .filter(prop => typeof instance[prop] === 'function' && prop !== 'constructor');
+  } else {
+    // Si es un objeto con funciones directamente
+    handlerNames = Object.keys(controllerModule).filter(key =>
+      typeof controllerModule[key] === 'function'
+    );
+  }
+
+  // Almacenar información sobre el controlador
+  availableControllers.push({
+    name: controllerName,
+    path: absolutePath,
+    handlers: handlerNames
+  });
+
+  logger.info(`[[HOOK]] - Handlers disponibles en ${controllerName}:`, handlerNames);
+});
+
+// Hook que se ejecuta antes de cargar rutas
+hooks.addAction('pre_route_load', (filePath, serverInstance) => {
+  logger.info(`[[HOOK]] - A punto de cargar rutas desde: ${filePath}`);
+});
+
+// Hook que se ejecuta después de cargar rutas
+hooks.addAction('post_route_load', (routes, serverInstance) => {
+  logger.info(`[[HOOK]] - Rutas cargadas exitosamente: ${routes.length} rutas`);
+  routes.forEach((route, index) => {
+    logger.info(`[[HOOK]] - Ruta ${index + 1}: ${route.method} ${route.path} -> ${route.handlerName || 'anonymous'}`);
+  });
+});
+
+// Hook para registrar accesos al servidor
+hooks.addAction('request_received', (req, res) => {
+  logger.info(`[[ACCESS]] - Nuevo acceso recibido: ${req.method} ${req.url} desde ${req.connection.remoteAddress || 'unknown'}`);
+});
+
+// Hook para registrar descargas o finalización de solicitudes
+hooks.addAction('request_completed', (req, res) => {
+  logger.info(`[[DOWNLOAD/COMPLETED]] - Solicitud completada: ${req.method} ${req.url}`);
+});
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 11000,
+    host: 'localhost'
+  });
+
+  try {
+    // Middleware para capturar inicio de solicitudes
+    server.use((req, res, next) => {
+      // Disparar hook de solicitud recibida
+      hooks.doAction('request_received', req, res);
+
+      // Guardar la función original de res.end
+      const originalEnd = res.end;
+
+      // Sobrescribir res.end para capturar cuando se completa la solicitud
+      res.end = function(chunk, encoding, callback) {
+        // Llamar a la función original
+        const result = originalEnd.call(this, chunk, encoding, callback);
+
+        // Disparar hook de solicitud completada
+        hooks.doAction('request_completed', req, res);
+
+        return result;
+      };
+
+      next();
+    });
+
+    // Cargar rutas desde archivo JSON
+    const routeLoader = new RouteLoader();
+    await routeLoader.loadRoutes(server, './routes.json');
+
+    // Mostrar los controladores disponibles (usando hooks)
+    logger.info('\n=== CONTROLADORES DISPONIBLES ===');
+    availableControllers.forEach((controller, index) => {
+      logger.info(`[[CONTROLLER ${index + 1}]] - Nombre: ${controller.name}`);
+      logger.info(`[[PATH]] - Ruta: ${controller.path}`);
+      logger.info(`[[HANDLERS]] - Funciones: ${controller.handlers.join(', ')}`);
+      logger.info('---');
+    });
+
+    // Iniciar el servidor
+    server.start();
+
+    logger.info(`\nServidor iniciado en http://localhost:${server.port}`);
+    logger.info('La aplicación está lista para recibir solicitudes');
+
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/examples/hooks/controllers/authController.js

@@ -0,0 +1,54 @@
+/**
+ * Controlador de autenticación (authController)
+ * Maneja operaciones de login
+ */
+
+// Datos simulados de usuarios para autenticación
+const validUsers = [
+  { username: 'admin', password: 'admin123' },
+  { username: 'user', password: 'user123' }
+];
+
+// Función de login
+function login(req, res) {
+  let body = '';
+  
+  req.on('data', chunk => {
+    body += chunk.toString();
+  });
+  
+  req.on('end', () => {
+    try {
+      const credentials = JSON.parse(body);
+      const user = validUsers.find(u => 
+        u.username === credentials.username && 
+        u.password === credentials.password
+      );
+      
+      if (user) {
+        // Simular generación de token JWT
+        const token = `fake-jwt-token-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          success: true, 
+          token: token,
+          message: 'Login exitoso'
+        }));
+      } else {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          success: false, 
+          message: 'Credenciales inválidas' 
+        }));
+      }
+    } catch (error) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Datos inválidos' }));
+    }
+  });
+}
+
+module.exports = {
+  login
+};

package/examples/hooks/controllers/mainController.js

@@ -0,0 +1,41 @@
+/**
+ * Controlador principal (mainController)
+ * Maneja la página de inicio
+ */
+
+const { ControllerBase } = require('jerkjs');
+
+class MainController extends ControllerBase {
+  constructor(options = {}) {
+    super(options);
+  }
+
+  // Función para manejar la ruta de inicio
+  home(req, res) {
+    // Establecer variables para la vista
+    this.set('title', 'Bienvenido a JERK Framework');
+    this.set('message', 'Esta es una aplicación de ejemplo usando JERK Framework');
+
+    // Renderizar la vista usando el motor de plantillas de JERK
+    this.render(res, 'home', {
+      endpoints: [
+        { method: 'GET', path: '/users', description: 'Obtener todos los usuarios' },
+        { method: 'GET', path: '/users/:id', description: 'Obtener usuario por ID' },
+        { method: 'POST', path: '/users', description: 'Crear nuevo usuario' },
+        { method: 'GET', path: '/products', description: 'Obtener todos los productos' },
+        { method: 'GET', path: '/products/:id', description: 'Obtener producto por ID' },
+        { method: 'POST', path: '/login', description: 'Iniciar sesión' }
+      ]
+    });
+  }
+}
+
+// Exportar métodos directamente para que el RouteLoader pueda acceder a ellos
+const controllerInstance = new MainController({ viewsPath: './views' });
+
+module.exports = {
+  home: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.home(req, res);
+  }
+};

package/examples/hooks/controllers/productController.js

@@ -0,0 +1,39 @@
+/**
+ * Controlador de productos (productController)
+ * Maneja operaciones CRUD de productos
+ */
+
+// Datos simulados de productos
+let products = [
+  { id: 1, name: 'Laptop', price: 1200, category: 'Electrónica' },
+  { id: 2, name: 'Teléfono', price: 800, category: 'Electrónica' },
+  { id: 3, name: 'Libro', price: 15, category: 'Educación' }
+];
+
+// Obtener todos los productos
+function getAllProducts(req, res) {
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(products));
+}
+
+// Obtener un producto por ID
+function getProductById(req, res) {
+  // Obtener el ID de los parámetros de la ruta
+  const urlParts = req.url.split('/');
+  const productId = parseInt(urlParts[urlParts.length - 1]);
+  
+  const product = products.find(p => p.id === productId);
+  
+  if (product) {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(product));
+  } else {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Producto no encontrado' }));
+  }
+}
+
+module.exports = {
+  getAllProducts,
+  getProductById
+};

package/examples/hooks/controllers/userController.js

@@ -0,0 +1,69 @@
+/**
+ * Controlador de usuarios (userController)
+ * Maneja operaciones CRUD de usuarios
+ */
+
+// Datos simulados de usuarios
+let users = [
+  { id: 1, name: 'Juan Pérez', email: 'juan@example.com', age: 30 },
+  { id: 2, name: 'María García', email: 'maria@example.com', age: 25 },
+  { id: 3, name: 'Pedro Rodríguez', email: 'pedro@example.com', age: 35 }
+];
+
+// Obtener todos los usuarios
+function getAllUsers(req, res) {
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(users));
+}
+
+// Obtener un usuario por ID
+function getUserById(req, res) {
+  // Obtener el ID de los parámetros de la ruta
+  const urlParts = req.url.split('/');
+  const userId = parseInt(urlParts[urlParts.length - 1]);
+  
+  const user = users.find(u => u.id === userId);
+  
+  if (user) {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(user));
+  } else {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Usuario no encontrado' }));
+  }
+}
+
+// Crear un nuevo usuario
+function createUser(req, res) {
+  let body = '';
+  
+  req.on('data', chunk => {
+    body += chunk.toString();
+  });
+  
+  req.on('end', () => {
+    try {
+      const userData = JSON.parse(body);
+      const newUser = {
+        id: users.length + 1,
+        name: userData.name,
+        email: userData.email,
+        age: userData.age
+      };
+      
+      users.push(newUser);
+      
+      res.writeHead(201, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(newUser));
+    } catch (error) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Datos inválidos' }));
+    }
+  });
+}
+
+module.exports = {
+  getAllUsers,
+  getUserById,
+  createUser
+};

package/examples/hooks/routes.json

@@ -0,0 +1,51 @@
+[
+  {
+    "method": "GET",
+    "path": "/",
+    "controller": "./controllers/mainController.js",
+    "handler": "home",
+    "auth": "none"
+  },
+  {
+    "method": "GET",
+    "path": "/users",
+    "controller": "./controllers/userController.js",
+    "handler": "getAllUsers",
+    "auth": "none"
+  },
+  {
+    "method": "GET",
+    "path": "/users/:id",
+    "controller": "./controllers/userController.js",
+    "handler": "getUserById",
+    "auth": "none"
+  },
+  {
+    "method": "POST",
+    "path": "/users",
+    "controller": "./controllers/userController.js",
+    "handler": "createUser",
+    "auth": "required"
+  },
+  {
+    "method": "GET",
+    "path": "/products",
+    "controller": "./controllers/productController.js",
+    "handler": "getAllProducts",
+    "auth": "none"
+  },
+  {
+    "method": "GET",
+    "path": "/products/:id",
+    "controller": "./controllers/productController.js",
+    "handler": "getProductById",
+    "auth": "none"
+  },
+  {
+    "method": "POST",
+    "path": "/login",
+    "controller": "./controllers/authController.js",
+    "handler": "login",
+    "auth": "none"
+  }
+]

package/examples/hooks/views/home.html

@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html lang="es">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{title}}</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 40px;
+            background-color: #f5f5f5;
+        }
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+        }
+        h1 {
+            color: #333;
+        }
+        .api-info {
+            margin-top: 20px;
+            padding: 15px;
+            background-color: #e7f3ff;
+            border-left: 4px solid #2196F3;
+        }
+        .endpoint-item {
+            margin: 5px 0;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>{{title}}</h1>
+        <p>{{message}}</p>
+
+        <div class="api-info">
+            <h2>Endpoints disponibles:</h2>
+            <ul>
+                {{foreach:endpoints}}
+                <li class="endpoint-item"><strong>{{item.method}}</strong> {{item.path}} - {{item.description}}</li>
+                {{endforeach}}
+            </ul>
+        </div>
+    </div>
+</body>
+</html>

package/index.js

@@ -1,6 +1,6 @@
 /**
  * Punto de entrada del framework JERK
- * JERK Framework v2.0
+ * JERK Framework v2.1
  */
 
 const APIServer = require('./lib/core/server');
@@ -34,6 +34,9 @@ const { SessionManager, sessionAuth } = require('./lib/middleware/session');
 const ViewEngine = require('./lib/mvc/viewEngine');
 const ControllerBase = require('./lib/mvc/controllerBase');
 
+// Componentes de manejo de errores
+const { ErrorHandler, ValidationError, AuthenticationError, DatabaseError } = require('./lib/utils/errorHandler');
+
 // Exportar todos los componentes del framework
 module.exports = {
   // Componentes fundamentales (v1.0)
@@ -72,7 +75,13 @@ module.exports = {
 
   // Componentes MVC (v2.3.0)
   ViewEngine,
-  ControllerBase
+  ControllerBase,
+
+  // Componentes de manejo de errores (v2.4.0)
+  ErrorHandler,
+  ValidationError,
+  AuthenticationError,
+  DatabaseError
 };
 
 // También exportar clases individuales por conveniencia

package/lib/core/router.js

@@ -2,6 +2,7 @@
  * Sistema de enrutamiento avanzado para el framework JERK
  * Implementación extendida del componente core/router.js
  * Incluye soporte para rutas anidadas y otras mejoras
+ * JERK Framework v2.1 - Con cacheo de expresiones regulares para rutas parametrizadas
  */
 
 class Router {

package/lib/core/securityEnhancedServer.js

@@ -2,6 +2,7 @@
  * Implementación completa del sistema de seguridad avanzada (WAF)
  * usando el sistema de hooks y filters para extensibilidad
  * Web Application Firewall con capacidades de detección y prevención de ataques
+ * JERK Framework v2.1 - Con optimizaciones de rendimiento
  */
 
 const APIServer = require('../core/server');

package/lib/core/server.js

@@ -1,6 +1,7 @@
 /**
  * Servidor HTTP básico para el framework JERK
  * Implementación del componente core/server.js
+ * JERK Framework v2.1 - Con optimizaciones de rendimiento
  */
 
 const http = require('http');
@@ -8,6 +9,7 @@ const https = require('https');
 const url = require('url');
 const fs = require('fs');
 const { Logger } = require('../utils/logger');
+const { ErrorHandler } = require('../utils/errorHandler');
 
 class APIServer {
   /**
@@ -42,6 +44,9 @@ class APIServer {
     this.middlewares = [];
     this.logger = new Logger();
     this.server = null;
+
+    // Cache de expresiones regulares para rutas parametrizadas
+    this.routeRegexCache = new Map();
   }
 
   /**
@@ -111,8 +116,12 @@ class APIServer {
    * @returns {RegExp} - Expresión regular para la ruta
    */
   pathToRegex(path) {
-    // Escapar caracteres especiales de la ruta, excepto los parámetros
-    // Pero dejar : sin escapar ya que lo usaremos para identificar parámetros
+    // Verificar si ya está en caché
+    if (this.routeRegexCache.has(path)) {
+      return this.routeRegexCache.get(path);
+    }
+
+    // Lógica de escape de caracteres especiales
     let escapedPath = '';
     for (let i = 0; i < path.length; i++) {
       const char = path[i];
@@ -124,7 +133,11 @@ class APIServer {
     }
     // Reemplazar parámetros :param con grupos de captura no greedy para evitar problemas de matching
     const regexPath = escapedPath.replace(/:([a-zA-Z0-9_]+)/g, '([^/]+?)');
-    return new RegExp(`^${regexPath}$`);
+    const regex = new RegExp(`^${regexPath}$`);
+
+    // Almacenar en caché
+    this.routeRegexCache.set(path, regex);
+    return regex;
   }
 
   /**
@@ -177,6 +190,10 @@ class APIServer {
       this.server = http.createServer(this.handleRequest.bind(this));
     }
 
+    // Configurar keep-alive para conexiones persistentes
+    this.server.keepAliveTimeout = 60000; // 60 segundos
+    this.server.headersTimeout = 65000; // 65 segundos (mayor que keepAliveTimeout)
+
     // Configurar timeouts
     this.server.setTimeout(this.requestTimeout);
     this.server.on('timeout', (socket) => {
@@ -200,6 +217,9 @@ class APIServer {
         this.logger.info(`Servidor iniciado en http://${this.host}:${this.port}`);
       }
 
+      // Verificar uso de memoria en el hook de inicio
+      this.logger.logMemoryUsage();
+
       // Disparar hook después de iniciar el servidor
       if (hooks) {
         hooks.doAction('post_server_start', this);
@@ -232,7 +252,9 @@ class APIServer {
     // Agregar propiedades útiles a la solicitud
     req.query = query;
     req.params = {};
-    req.body = '';
+
+    // Inicializar array para acumular chunks del body
+    const bodyChunks = [];
 
     // Configurar límite de tamaño para el cuerpo de la solicitud desde configuración
     let bodySize = 0;
@@ -246,11 +268,14 @@ class APIServer {
         req.destroy(); // Terminar la conexión
         return;
       }
-      req.body += chunk.toString();
+      bodyChunks.push(chunk);
     });
 
     req.on('end', async () => {
       try {
+        // Concatenar todos los chunks una sola vez
+        req.body = Buffer.concat(bodyChunks).toString();
+
         // Parsear body si es JSON
         if (req.headers['content-type'] && req.headers['content-type'].includes('application/json')) {
           try {
@@ -358,9 +383,7 @@ class APIServer {
           }
         }
       } catch (error) {
-        this.logger.error('Error procesando la solicitud:', error.message);
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Error interno del servidor', details: error.message }));
+        ErrorHandler.handle(error, req, res, this.logger);
       }
     });
   }

package/lib/loader/routeLoader.js

@@ -1,6 +1,7 @@
 /**
  * Carga de rutas desde archivos JSON para el framework JERK
  * Implementación del componente loader/routeLoader.js
+ * JERK Framework v2.1 - Con cacheo de expresiones regulares para rutas parametrizadas
  */
 
 const fs = require('fs');

package/lib/middleware/compressor.js

@@ -1,6 +1,7 @@
 /**
  * Middleware de compresión para el framework JERK
  * Implementación del componente middleware/compressor.js
+ * JERK Framework v2.1 - Con optimizaciones de eficiencia
  */
 
 const zlib = require('zlib');
@@ -53,21 +54,26 @@ class Compressor {
       const originalEnd = res.end;
       const originalWriteHead = res.writeHead;
 
-      // Variable para almacenar el cuerpo de la respuesta
-      let responseBody = '';
-      
-      // Sobrescribir res.write para capturar el cuerpo
+      // Array para almacenar los chunks de la respuesta
+      const responseChunks = [];
+
+      // Sobrescribir res.write para capturar los chunks
       res.write = (chunk, encoding) => {
-        responseBody += chunk;
+        responseChunks.push(chunk);
       };
 
       // Sobrescribir res.end para comprimir antes de enviar
       res.end = (chunk, encoding) => {
-        // Añadir el chunk final al cuerpo si existe
+        // Añadir el chunk final a los chunks si existe
         if (chunk) {
-          responseBody += chunk;
+          responseChunks.push(chunk);
         }
 
+        // Concatenar todos los chunks una sola vez
+        const responseBody = Buffer.concat(responseChunks.map(c =>
+          typeof c === 'string' ? Buffer.from(c, encoding) : c
+        )).toString();
+
         // Si el cuerpo es menor que el umbral, enviar sin comprimir
         if (Buffer.byteLength(responseBody) < this.threshold) {
           res.removeHeader('Content-Encoding'); // Asegurar que no haya encabezado de codificación
@@ -108,10 +114,10 @@ class Compressor {
             // Establecer encabezados apropiados
             res.setHeader('Content-Encoding', compressionMethod);
             res.removeHeader('Content-Length'); // Eliminar Content-Length original
-            
+
             // Llamar al writeHead original
             originalWriteHead.call(res);
-            
+
             // Enviar el cuerpo comprimido
             originalEnd.call(res, compressed, encoding);
           })
@@ -145,7 +151,7 @@ class Compressor {
         if (contentType && contentType.includes('application/json')) {
           // Convertir a string si no lo es
           const jsonString = typeof data === 'string' ? data : JSON.stringify(data);
-          
+
           // Continuar con la lógica de compresión
           // (similar a la implementación en middleware())
           const acceptEncoding = req.headers['accept-encoding'];