jerkjs 2.1.6 → 2.2.0

package/lib/loader/routeLoader.js

@@ -83,12 +83,29 @@ class RouteLoader {
         throw new Error(`La ruta en la posición ${i} no tiene propiedad 'method'`);
       }
 
-      if (!route.controller) {
-        throw new Error(`La ruta en la posición ${i} no tiene propiedad 'controller'`);
-      }
+      // Verificar si es una ruta estática
+      if (route.static) {
+        if (typeof route.static !== 'object' || route.static === null) {
+          throw new Error(`La ruta en la posición ${i} tiene una propiedad 'static' inválida`);
+        }
+
+        if (!route.static.dir) {
+          throw new Error(`La ruta en la posición ${i} tiene una configuración 'static' sin directorio 'dir'`);
+        }
+
+        // El método debe ser GET para rutas estáticas
+        if (route.method.toUpperCase() !== 'GET') {
+          throw new Error(`Las rutas estáticas deben usar el método GET, no ${route.method}`);
+        }
+      } else {
+        // Validación normal para rutas dinámicas
+        if (!route.controller) {
+          throw new Error(`La ruta en la posición ${i} no tiene propiedad 'controller'`);
+        }
 
-      if (!route.handler) {
-        throw new Error(`La ruta en la posición ${i} no tiene propiedad 'handler'`);
+        if (!route.handler) {
+          throw new Error(`La ruta en la posición ${i} no tiene propiedad 'handler'`);
+        }
       }
 
       // Validar que el content-type sea un string si está presente
@@ -104,134 +121,148 @@ class RouteLoader {
    * @param {Object} route - Objeto de ruta a cargar
    */
   async loadSingleRoute(server, route) {
-    // Obtener el controlador
-    const controllerPath = path.resolve(process.cwd(), route.controller);
-    let controllerModule;
-
-    try {
-      controllerModule = require(controllerPath);
-    } catch (error) {
-      throw new Error(`No se pudo cargar el controlador: ${route.controller}. Error: ${error.message}`);
-    }
+    // Verificar si es una ruta estática
+    if (route.static) {
+      // Para rutas estáticas, simplemente llamar a addRoute con la configuración estática
+      server.addRoute({
+        method: route.method,
+        path: route.path,
+        static: route.static,
+        contentType: route.contentType,
+        auth: route.auth,
+        authOptions: route.authOptions
+      });
+    } else {
+      // Lógica existente para rutas dinámicas
+      // Obtener el controlador
+      const controllerPath = path.resolve(process.cwd(), route.controller);
+      let controllerModule;
+
+      try {
+        controllerModule = require(controllerPath);
+      } catch (error) {
+        throw new Error(`No se pudo cargar el controlador: ${route.controller}. Error: ${error.message}`);
+      }
 
-    // Obtener el handler del controlador
-    const handler = controllerModule[route.handler];
-    if (typeof handler !== 'function') {
-      throw new Error(`El handler '${route.handler}' no es una función en el controlador: ${route.controller}`);
-    }
+      // Obtener el handler del controlador
+      const handler = controllerModule[route.handler];
+      if (typeof handler !== 'function') {
+        throw new Error(`El handler '${route.handler}' no es una función en el controlador: ${route.controller}`);
+      }
 
-    // Crear un handler que establezca el content-type si está especificado
-    let finalHandler = handler;
+      // Crear un handler que establezca el content-type si está especificado
+      let finalHandler = handler;
 
-    if (route.contentType) {
-      finalHandler = async (req, res) => {
-        // Establecer el content-type antes de ejecutar el handler original
-        res.setHeader('Content-Type', route.contentType);
+      if (route.contentType) {
+        finalHandler = async (req, res) => {
+          // Establecer el content-type antes de ejecutar el handler original
+          res.setHeader('Content-Type', route.contentType);
 
-        // Si el handler es asíncrono, esperarlo
-        if (handler.constructor.name === 'AsyncFunction') {
-          await handler(req, res);
-        } else {
-          handler(req, res);
-        }
-      };
-    }
+          // Si el handler es asíncrono, esperarlo
+          if (handler.constructor.name === 'AsyncFunction') {
+            await handler(req, res);
+          } else {
+            handler(req, res);
+          }
+        };
+      }
 
-    // Aplicar autenticación si está especificada
-    if (route.auth && route.auth !== 'none') {
-      // Verificar si es autenticación de sesión
-      if (route.auth === 'session') {
-        // Verificar si el servidor tiene sessionManager
-        if (server.sessionManager) {
-          // Importar el middleware de autenticación de sesión
-          const { sessionAuth } = require('../middleware/session');
-          const authMiddleware = sessionAuth(server.sessionManager, route.authOptions || {});
-
-          // Crear un nuevo handler que ejecute la autenticación primero
-          const authenticatedHandler = async (req, res) => {
-            try {
-              // Ejecutar el middleware de autenticación y esperar a que se resuelva
-              await new Promise((resolve, reject) => {
-                const next = () => resolve();
-                const result = authMiddleware(req, res, next);
-
-                // Si authMiddleware devuelve una promesa, esperarla
-                if (result && typeof result.then === 'function') {
-                  result.then(resolve).catch(reject);
+      // Aplicar autenticación si está especificada
+      if (route.auth && route.auth !== 'none') {
+        // Verificar si es autenticación de sesión
+        if (route.auth === 'session') {
+          // Verificar si el servidor tiene sessionManager
+          if (server.sessionManager) {
+            // Importar el middleware de autenticación de sesión
+            const { sessionAuth } = require('../middleware/session');
+            const authMiddleware = sessionAuth(server.sessionManager, route.authOptions || {});
+
+            // Crear un nuevo handler que ejecute la autenticación primero
+            const authenticatedHandler = async (req, res) => {
+              try {
+                // Ejecutar el middleware de autenticación y esperar a que se resuelva
+                await new Promise((resolve, reject) => {
+                  const next = () => resolve();
+                  const result = authMiddleware(req, res, next);
+
+                  // Si authMiddleware devuelve una promesa, esperarla
+                  if (result && typeof result.then === 'function') {
+                    result.then(resolve).catch(reject);
+                  }
+                });
+
+                // Si la autenticación fue exitosa (no se envió respuesta aún), ejecutar el handler original
+                if (!res.headersSent) {
+                  // Si el handler es asíncrono, esperarlo también
+                  if (finalHandler.constructor.name === 'AsyncFunction') {
+                    await finalHandler(req, res);
+                  } else {
+                    finalHandler(req, res);
+                  }
                 }
-              });
-
-              // Si la autenticación fue exitosa (no se envió respuesta aún), ejecutar el handler original
-              if (!res.headersSent) {
-                // Si el handler es asíncrono, esperarlo también
-                if (finalHandler.constructor.name === 'AsyncFunction') {
-                  await finalHandler(req, res);
-                } else {
-                  finalHandler(req, res);
+              } catch (error) {
+                console.error('Error en el manejo de autenticación de sesión:', error);
+                if (!res.headersSent) {
+                  res.writeHead(500, { 'Content-Type': 'application/json' });
+                  res.end(JSON.stringify({ error: 'Error interno del servidor' }));
                 }
               }
-            } catch (error) {
-              console.error('Error en el manejo de autenticación de sesión:', error);
-              if (!res.headersSent) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-              }
-            }
-          };
+            };
 
-          // Agregar la ruta con el handler autenticado
-          server.addRoute(route.method, route.path, authenticatedHandler);
+            // Agregar la ruta con el handler autenticado
+            server.addRoute(route.method, route.path, authenticatedHandler);
+          } else {
+            // Si no hay sessionManager en el servidor, agregar la ruta normalmente
+            server.addRoute(route.method, route.path, finalHandler);
+          }
         } else {
-          // Si no hay sessionManager en el servidor, agregar la ruta normalmente
-          server.addRoute(route.method, route.path, finalHandler);
-        }
-      } else {
-        // Usar el authenticator del servidor si está disponible para otros tipos de autenticación
-        if (server.authenticator) {
-          const authMiddleware = server.authenticator.authenticate(route.auth, route.authOptions || {});
-
-          // Crear un nuevo handler que ejecute la autenticación primero
-          const authenticatedHandler = async (req, res) => {
-            try {
-              // Ejecutar el middleware de autenticación y esperar a que se resuelva
-              await new Promise((resolve, reject) => {
-                const next = () => resolve();
-                const result = authMiddleware(req, res, next);
-
-                // Si authMiddleware devuelve una promesa, esperarla
-                if (result && typeof result.then === 'function') {
-                  result.then(resolve).catch(reject);
+          // Usar el authenticator del servidor si está disponible para otros tipos de autenticación
+          if (server.authenticator) {
+            const authMiddleware = server.authenticator.authenticate(route.auth, route.authOptions || {});
+
+            // Crear un nuevo handler que ejecute la autenticación primero
+            const authenticatedHandler = async (req, res) => {
+              try {
+                // Ejecutar el middleware de autenticación y esperar a que se resuelva
+                await new Promise((resolve, reject) => {
+                  const next = () => resolve();
+                  const result = authMiddleware(req, res, next);
+
+                  // Si authMiddleware devuelve una promesa, esperarla
+                  if (result && typeof result.then === 'function') {
+                    result.then(resolve).catch(reject);
+                  }
+                });
+
+                // Si la autenticación fue exitosa (no se envió respuesta aún), ejecutar el handler original
+                if (!res.headersSent) {
+                  // Si el handler es asíncrono, esperarlo también
+                  if (finalHandler.constructor.name === 'AsyncFunction') {
+                    await finalHandler(req, res);
+                  } else {
+                    finalHandler(req, res);
+                  }
                 }
-              });
-
-              // Si la autenticación fue exitosa (no se envió respuesta aún), ejecutar el handler original
-              if (!res.headersSent) {
-                // Si el handler es asíncrono, esperarlo también
-                if (finalHandler.constructor.name === 'AsyncFunction') {
-                  await finalHandler(req, res);
-                } else {
-                  finalHandler(req, res);
+              } catch (error) {
+                console.error('Error en el manejo de autenticación:', error);
+                if (!res.headersSent) {
+                  res.writeHead(500, { 'Content-Type': 'application/json' });
+                  res.end(JSON.stringify({ error: 'Error interno del servidor' }));
                 }
               }
-            } catch (error) {
-              console.error('Error en el manejo de autenticación:', error);
-              if (!res.headersSent) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-              }
-            }
-          };
+            };
 
-          // Agregar la ruta con el handler autenticado
-          server.addRoute(route.method, route.path, authenticatedHandler);
-        } else {
-          // Si no hay authenticator en el servidor, agregar la ruta normalmente
-          server.addRoute(route.method, route.path, finalHandler);
+            // Agregar la ruta con el handler autenticado
+            server.addRoute(route.method, route.path, authenticatedHandler);
+          } else {
+            // Si no hay authenticator en el servidor, agregar la ruta normalmente
+            server.addRoute(route.method, route.path, finalHandler);
+          }
         }
+      } else {
+        // Si no hay autenticación requerida, agregar la ruta normalmente
+        server.addRoute(route.method, route.path, finalHandler);
       }
-    } else {
-      // Si no hay autenticación requerida, agregar la ruta normalmente
-      server.addRoute(route.method, route.path, finalHandler);
     }
   }
 

package/lib/middleware/compressor.js

@@ -64,6 +64,39 @@ class Compressor {
       // Array para almacenar los chunks de la respuesta
       const responseChunks = [];
 
+      // Variables para almacenar información del encabezado
+      let statusCode = 200;
+      let responseHeaders = {};
+
+      // Sobrescribir res.writeHead para capturar los encabezados
+      res.writeHead = (code, headers) => {
+        statusCode = code;
+        if (typeof headers === 'object' && headers !== null) {
+          responseHeaders = { ...headers };
+        } else if (typeof headers === 'string') {
+          // Si headers es una string, intentar parsearla
+          try {
+            // Esto es un caso especial, normalmente headers debería ser un objeto
+            responseHeaders = { 'Content-Type': headers };
+          } catch (e) {
+            responseHeaders = {};
+          }
+        }
+
+        // Permitir a los hooks modificar los encabezados antes de escribirlos
+        if (this.hooks && this.hooks.applyFilters) {
+          responseHeaders = this.hooks.applyFilters('compressor_response_headers', responseHeaders, req, res);
+        }
+
+        // NO LLAMAR A ORIGINAL WRITEHEAD AÚN - ESPERAR A VER SI NECESITAMOS COMPRIMIR
+        // Marcar que writeHead ha sido llamado pero diferir el envío real
+        res.__hasCalledWriteHead = true;
+        res.__pendingStatusCode = code;
+        res.__pendingHeaders = { ...headers };
+
+        return res;
+      };
+
       // Sobrescribir res.write para capturar los chunks
       res.write = (chunk, encoding) => {
         // Permitir a los hooks interceptar los chunks antes de almacenarlos
@@ -101,7 +134,7 @@ class Compressor {
             const shouldCompress = this.hooks.applyFilters('compressor_should_compress', false, responseBody, req, res, this.threshold);
             if (shouldCompress) {
               // Si un hook determina que debería comprimirse, proseguir con la compresión
-              this._performCompression(req, res, originalEnd, originalWriteHead, responseBody, compressionMethod);
+              this._performCompression(req, res, originalEnd, originalWriteHead, responseBody, compressionMethod, statusCode, responseHeaders);
               return;
             }
           }
@@ -113,8 +146,16 @@ class Compressor {
 
           // Solo establecer encabezados si no se han enviado aún
           if (!res.headersSent) {
-            res.removeHeader('Content-Encoding'); // Asegurar que no haya encabezado de codificación
-            originalWriteHead.call(res);
+            // Restaurar encabezados originales y asegurar que no haya encabezado de codificación
+            const headersToSend = { ...responseHeaders };
+            delete headersToSend['content-encoding']; // Asegurar que no haya encabezado de codificación
+
+            // Si writeHead fue llamado previamente, usar los encabezados pendientes
+            if (res.__hasCalledWriteHead && res.__pendingHeaders) {
+              originalWriteHead.call(res, res.__pendingStatusCode || statusCode, headersToSend);
+            } else {
+              originalWriteHead.call(res, statusCode, headersToSend);
+            }
           }
           originalEnd.call(res, responseBody, encoding);
           return;
@@ -169,17 +210,24 @@ class Compressor {
 
             // Solo establecer encabezados si no se han enviado aún
             if (!res.headersSent) {
-              // Establecer encabezados apropiados
-              res.setHeader('Content-Encoding', compressionMethod);
-              res.removeHeader('Content-Length'); // Eliminar Content-Length original
+              // Combinar encabezados originales con el encabezado de compresión
+              const headersToSend = { ...responseHeaders };
+              headersToSend['Content-Encoding'] = compressionMethod;
+              delete headersToSend['content-length']; // Eliminar Content-Length original
 
               // Permitir a los hooks modificar los encabezados
               if (this.hooks && this.hooks.doAction) {
                 this.hooks.doAction('compressor_before_headers_sent', req, res, compressionMethod);
               }
 
-              // Llamar al writeHead original
-              originalWriteHead.call(res);
+              // Si writeHead fue llamado previamente, usar los encabezados pendientes
+              if (res.__hasCalledWriteHead && res.__pendingHeaders) {
+                // Combinar los encabezados pendientes con el encabezado de compresión
+                const combinedHeaders = { ...res.__pendingHeaders, ...headersToSend };
+                originalWriteHead.call(res, res.__pendingStatusCode || statusCode, combinedHeaders);
+              } else {
+                originalWriteHead.call(res, statusCode, headersToSend);
+              }
             }
 
             // Permitir a los hooks modificar el comportamiento antes de enviar la respuesta
@@ -204,8 +252,15 @@ class Compressor {
 
             // Si ocurre un error, enviar sin comprimir
             if (!res.headersSent) {
-              res.removeHeader('Content-Encoding');
-              originalWriteHead.call(res);
+              const headersToSend = { ...responseHeaders };
+              delete headersToSend['content-encoding'];
+
+              // Si writeHead fue llamado previamente, usar los encabezados pendientes
+              if (res.__hasCalledWriteHead && res.__pendingHeaders) {
+                originalWriteHead.call(res, res.__pendingStatusCode || statusCode, { ...res.__pendingHeaders, ...headersToSend });
+              } else {
+                originalWriteHead.call(res, statusCode, headersToSend);
+              }
             }
             originalEnd.call(res, responseBody, encoding);
           });
@@ -390,7 +445,7 @@ class Compressor {
    * Método auxiliar para realizar la compresión
    * @private
    */
-  _performCompression(req, res, originalEnd, originalWriteHead, responseBody, compressionMethod) {
+  _performCompression(req, res, originalEnd, originalWriteHead, responseBody, compressionMethod, statusCode = 200, responseHeaders = {}) {
     const zlib = require('zlib');
 
     // Permitir a los hooks modificar el comportamiento cuando se va a comprimir
@@ -442,17 +497,24 @@ class Compressor {
 
         // Solo establecer encabezados si no se han enviado aún
         if (!res.headersSent) {
-          // Establecer encabezados apropiados
-          res.setHeader('Content-Encoding', compressionMethod);
-          res.removeHeader('Content-Length'); // Eliminar Content-Length original
+          // Combinar encabezados originales con el encabezado de compresión
+          const headersToSend = { ...responseHeaders };
+          headersToSend['Content-Encoding'] = compressionMethod;
+          delete headersToSend['content-length']; // Eliminar Content-Length original
 
           // Permitir a los hooks modificar los encabezados
           if (this.hooks && this.hooks.doAction) {
             this.hooks.doAction('compressor_before_headers_sent', req, res, compressionMethod);
           }
 
-          // Llamar al writeHead original
-          originalWriteHead.call(res);
+          // Si writeHead fue llamado previamente, usar los encabezados pendientes
+          if (res.__hasCalledWriteHead && res.__pendingHeaders) {
+            // Combinar los encabezados pendientes con el encabezado de compresión
+            const combinedHeaders = { ...res.__pendingHeaders, ...headersToSend };
+            originalWriteHead.call(res, res.__pendingStatusCode || statusCode, combinedHeaders);
+          } else {
+            originalWriteHead.call(res, statusCode, headersToSend);
+          }
         }
 
         // Permitir a los hooks modificar el comportamiento antes de enviar la respuesta
@@ -477,8 +539,15 @@ class Compressor {
 
         // Si ocurre un error, enviar sin comprimir
         if (!res.headersSent) {
-          res.removeHeader('Content-Encoding');
-          originalWriteHead.call(res);
+          const headersToSend = { ...responseHeaders };
+          delete headersToSend['content-encoding'];
+
+          // Si writeHead fue llamado previamente, usar los encabezados pendientes
+          if (res.__hasCalledWriteHead && res.__pendingHeaders) {
+            originalWriteHead.call(res, res.__pendingStatusCode || statusCode, { ...res.__pendingHeaders, ...headersToSend });
+          } else {
+            originalWriteHead.call(res, statusCode, headersToSend);
+          }
         }
         originalEnd.call(res, responseBody);
       });

package/lib/mvc/GenericAdapter.js

@@ -0,0 +1,136 @@
+/**
+ * Adaptador genérico para modelos en el framework JERK
+ * Implementación del componente MVC GenericAdapter.js
+ * Proporciona una interfaz común para diferentes tipos de almacenamiento
+ */
+
+class GenericAdapter {
+  /**
+   * Constructor del adaptador genérico
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    this.options = options;
+    this.type = options.type || 'generic';
+    this.logger = options.logger || console;
+  }
+
+  /**
+   * Método para crear un registro
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} data - Datos a crear
+   * @returns {Promise<Object>} - Promesa con el resultado
+   */
+  async create(tableName, data) {
+    throw new Error('Método create no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para encontrar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones de búsqueda
+   * @param {Object} options - Opciones adicionales
+   * @returns {Promise<Array>} - Promesa con los resultados
+   */
+  async find(tableName, conditions, options) {
+    throw new Error('Método find no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para encontrar un solo registro
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones de búsqueda
+   * @param {Object} options - Opciones adicionales
+   * @returns {Promise<Object|null>} - Promesa con el resultado o null
+   */
+  async findOne(tableName, conditions, options) {
+    throw new Error('Método findOne no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para actualizar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones para seleccionar registros
+   * @param {Object} data - Datos a actualizar
+   * @returns {Promise<number>} - Promesa con el número de registros afectados
+   */
+  async update(tableName, conditions, data) {
+    throw new Error('Método update no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para eliminar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones para seleccionar registros
+   * @returns {Promise<number>} - Promesa con el número de registros eliminados
+   */
+  async delete(tableName, conditions) {
+    throw new Error('Método delete no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para contar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones de conteo
+   * @returns {Promise<number>} - Promesa con el número de registros
+   */
+  async count(tableName, conditions) {
+    throw new Error('Método count no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para ejecutar consultas personalizadas
+   * @param {string} query - Consulta personalizada
+   * @param {Array} params - Parámetros de la consulta
+   * @returns {Promise<any>} - Promesa con el resultado
+   */
+  async query(query, params = []) {
+    throw new Error('Método query no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para inicializar el adaptador
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    // Implementación por defecto
+  }
+
+  /**
+   * Método para cerrar la conexión
+   * @returns {Promise<void>}
+   */
+  async close() {
+    // Implementación por defecto
+  }
+
+  /**
+   * Método para verificar si el adaptador está conectado
+   * @returns {boolean} - Verdadero si está conectado
+   */
+  isConnected() {
+    return true; // Por defecto, asumimos que está conectado
+  }
+
+  /**
+   * Método para migrar una tabla
+   * @param {string} tableName - Nombre de la tabla a migrar
+   * @returns {Promise<void>}
+   */
+  async migrate(tableName) {
+    throw new Error('Método migrate no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Serializa el adaptador a JSON
+   * @returns {Object} - Representación JSON del adaptador
+   */
+  toJSON() {
+    return {
+      type: this.type,
+      initialized: true
+    };
+  }
+}
+
+module.exports = GenericAdapter;