jerkjs 2.1.7 → 2.2.0

package/lib/mvc/userModel.js

@@ -0,0 +1,265 @@
+/**
+ * Modelo de ejemplo para usuarios en el framework JERK
+ * Implementación del componente MVC userModel.js
+ * Extiende ModelBase para aprovechar todas las funcionalidades
+ */
+
+const ModelBase = require('./modelBase');
+
+class UserModel extends ModelBase {
+  /**
+   * Constructor del modelo de usuario
+   * @param {Object} options - Opciones de configuración del modelo
+   */
+  constructor(options = {}) {
+    super({
+      ...options,
+      tableName: options.tableName || 'users'
+    });
+    
+    // Definir campos del modelo
+    this.fields = {
+      id: { type: 'integer', primaryKey: true, autoIncrement: true },
+      username: { type: 'string', required: true, unique: true },
+      email: { type: 'string', required: true, unique: true },
+      password: { type: 'string', required: true },
+      firstName: { type: 'string' },
+      lastName: { type: 'string' },
+      createdAt: { type: 'datetime', default: 'CURRENT_TIMESTAMP' },
+      updatedAt: { type: 'datetime', default: 'CURRENT_TIMESTAMP' }
+    };
+  }
+
+  /**
+   * Valida los datos del usuario antes de guardar
+   * @param {string} operation - Operación a realizar
+   * @param {Object} data - Datos a validar
+   * @returns {Object} - Resultado de la validación
+   */
+  validate(operation, data) {
+    const result = { isValid: true, errors: [] };
+
+    // Validaciones específicas para creación
+    if (operation === 'create') {
+      if (!data.username) {
+        result.isValid = false;
+        result.errors.push('Username es requerido');
+      }
+
+      if (!data.email) {
+        result.isValid = false;
+        result.errors.push('Email es requerido');
+      }
+
+      if (!data.password) {
+        result.isValid = false;
+        result.errors.push('Password es requerido');
+      }
+    }
+
+    // Validaciones para actualización
+    if (operation === 'update') {
+      // Validar solo los campos que se están actualizando
+      if (data.hasOwnProperty('username') && !data.username) {
+        result.isValid = false;
+        result.errors.push('Username no puede estar vacío si se proporciona');
+      }
+
+      if (data.hasOwnProperty('email') && !data.email) {
+        result.isValid = false;
+        result.errors.push('Email no puede estar vacío si se proporciona');
+      }
+
+      if (data.hasOwnProperty('password') && !data.password) {
+        result.isValid = false;
+        result.errors.push('Password no puede estar vacío si se proporciona');
+      }
+
+      // Validar formato de email si se está actualizando
+      if (data.email && !this.isValidEmail(data.email)) {
+        result.isValid = false;
+        result.errors.push('Email no tiene un formato válido');
+      }
+    }
+
+    // Validaciones comunes para creación y actualización
+    if (operation === 'create' || operation === 'update') {
+      // Validar formato de email
+      if (data.email && !this.isValidEmail(data.email)) {
+        result.isValid = false;
+        result.errors.push('Email no tiene un formato válido');
+      }
+    }
+
+    // Disparar hook para validación
+    if (this.hooks) {
+      const validationResult = this.hooks.applyFilters(
+        'user_model_validate',
+        result,
+        operation,
+        data
+      );
+
+      return validationResult;
+    }
+
+    return result;
+  }
+
+  /**
+   * Verifica si un email tiene formato válido
+   * @param {string} email - Email a validar
+   * @returns {boolean} - Verdadero si el email es válido
+   */
+  isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  }
+
+  /**
+   * Busca un usuario por su nombre de usuario
+   * @param {string} username - Nombre de usuario a buscar
+   * @returns {Promise<Object|null>} - Usuario encontrado o null
+   */
+  async findByUsername(username) {
+    return await this.findOne({ username });
+  }
+
+  /**
+   * Busca un usuario por su email
+   * @param {string} email - Email a buscar
+   * @returns {Promise<Object|null>} - Usuario encontrado o null
+   */
+  async findByEmail(email) {
+    return await this.findOne({ email });
+  }
+
+  /**
+   * Crea un nuevo usuario con validación
+   * @param {Object} userData - Datos del usuario a crear
+   * @returns {Promise<Object>} - Usuario creado
+   */
+  async createUser(userData) {
+    // Validar datos antes de crear
+    const validation = this.validate('create', userData);
+    
+    if (!validation.isValid) {
+      throw new Error(`Validación fallida: ${validation.errors.join(', ')}`);
+    }
+    
+    // Encriptar contraseña antes de guardar
+    if (userData.password) {
+      userData.password = await this.hashPassword(userData.password);
+    }
+    
+    return await this.create(userData);
+  }
+
+  /**
+   * Actualiza un usuario con validación
+   * @param {Object} conditions - Condiciones para encontrar el usuario
+   * @param {Object} userData - Datos del usuario a actualizar
+   * @returns {Promise<number>} - Número de filas afectadas
+   */
+  async updateUser(conditions, userData) {
+    // Validar solo los campos que se están actualizando
+    const fieldsToUpdate = {};
+    for (const [key, value] of Object.entries(userData)) {
+      if (value !== undefined && value !== null) {
+        fieldsToUpdate[key] = value;
+      }
+    }
+
+    // Validar datos antes de actualizar
+    const validation = this.validate('update', fieldsToUpdate);
+
+    if (!validation.isValid) {
+      throw new Error(`Validación fallida: ${validation.errors.join(', ')}`);
+    }
+
+    // Encriptar contraseña si se proporciona
+    if (fieldsToUpdate.password) {
+      fieldsToUpdate.password = await this.hashPassword(fieldsToUpdate.password);
+    }
+
+    return await this.update(conditions, fieldsToUpdate);
+  }
+
+  /**
+   * Encripta una contraseña
+   * @param {string} password - Contraseña a encriptar
+   * @returns {Promise<string>} - Contraseña encriptada
+   */
+  async hashPassword(password) {
+    // Importar bcrypt dinámicamente
+    const bcrypt = require('bcrypt');
+    const saltRounds = 10;
+    return await bcrypt.hash(password, saltRounds);
+  }
+
+  /**
+   * Verifica si una contraseña coincide con el hash
+   * @param {string} password - Contraseña sin encriptar
+   * @param {string} hashedPassword - Contraseña encriptada
+   * @returns {Promise<boolean>} - Verdadero si coinciden
+   */
+  async verifyPassword(password, hashedPassword) {
+    // Importar bcrypt dinámicamente
+    const bcrypt = require('bcrypt');
+    return await bcrypt.compare(password, hashedPassword);
+  }
+
+  /**
+   * Obtiene usuarios con información paginada
+   * @param {Object} options - Opciones de paginación
+   * @param {number} options.page - Página a obtener (por defecto 1)
+   * @param {number} options.limit - Límite de resultados por página (por defecto 10)
+   * @param {Object} conditions - Condiciones de búsqueda
+   * @returns {Promise<Object>} - Resultados con información de paginación
+   */
+  async getUsersPaginated(options = {}, conditions = {}) {
+    const { page = 1, limit = 10 } = options;
+    const offset = (page - 1) * limit;
+    
+    // Obtener los usuarios para la página solicitada
+    const users = await this.find(conditions, {
+      limit,
+      offset,
+      orderBy: 'createdAt DESC'
+    });
+    
+    // Contar el total de usuarios
+    const totalCount = await this.count(conditions);
+    
+    // Calcular información de paginación
+    const totalPages = Math.ceil(totalCount / limit);
+    
+    return {
+      data: users,
+      pagination: {
+        currentPage: page,
+        totalPages,
+        totalItems: totalCount,
+        itemsPerPage: limit,
+        hasNextPage: page < totalPages,
+        hasPrevPage: page > 1
+      }
+    };
+  }
+
+  /**
+   * Serializa el modelo de usuario a JSON
+   * @returns {Object} - Representación JSON del modelo
+   */
+  toJSON() {
+    const baseJson = super.toJSON();
+    return {
+      ...baseJson,
+      modelName: this.constructor.name,
+      tableName: this.tableName,
+      fieldCount: Object.keys(this.fields).length
+    };
+  }
+}
+
+module.exports = UserModel;

package/lib/mvc/viewEngine.js

@@ -215,7 +215,7 @@ class ViewEngine {
   render(viewName, data = {}, options = {}) {
     // Obtener la ruta completa de la vista
     const viewPath = this.getViewPath(viewName);
-    
+
     // Verificar si la vista existe
     if (!fs.existsSync(viewPath)) {
       throw new Error(`Vista no encontrada: ${viewPath}`);
@@ -238,6 +238,37 @@ class ViewEngine {
       }
     }
 
+    // Si es una vista de contenido (no un layout), procesarla y usarla como contenido para el layout
+    if (options.layout) {
+      // Procesar la vista actual con las variables
+      const processedViewContent = this.processTemplate(viewContent, data, options);
+
+      // Cargar el layout
+      const layoutPath = this.getViewPath(options.layout);
+      if (fs.existsSync(layoutPath)) {
+        let layoutContent = fs.readFileSync(layoutPath, 'utf8');
+
+        // Validar sintaxis del layout si está habilitado
+        if (options.validateSyntax !== false) {
+          const layoutValidationErrors = ViewEngine.validateTemplate(layoutContent);
+          if (layoutValidationErrors.length > 0) {
+            this.logger.warn(`Errores de sintaxis en el layout ${options.layout}:`, layoutValidationErrors);
+          }
+        }
+
+        // Reemplazar el placeholder {{content}} con el contenido procesado
+        layoutContent = layoutContent.replace(/\{\{content\}\}/g, processedViewContent);
+
+        // Procesar el layout con las variables
+        layoutContent = this.processTemplate(layoutContent, data, options);
+
+        return layoutContent;
+      } else {
+        // Si no existe el layout, devolver solo la vista procesada
+        return this.processTemplate(viewContent, data, options);
+      }
+    }
+
     // Procesar bloques de inclusión (similar a <?php include ?>)
     viewContent = this.processIncludes(viewContent, path.dirname(viewPath));
 

package/lib/utils/mimeType.js

@@ -0,0 +1,62 @@
+/**
+ * Utilidad para determinar tipos MIME
+ * JERK Framework v2.1 - Sistema de tipos MIME con integración de hooks
+ */
+
+const mimeTypes = {
+  '.html': 'text/html',
+  '.htm': 'text/html',
+  '.js': 'application/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+  '.xml': 'application/xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.pdf': 'application/pdf',
+  '.txt': 'text/plain',
+  '.csv': 'text/csv',
+  '.zip': 'application/zip',
+  '.mp3': 'audio/mpeg',
+  '.mp4': 'video/mp4',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.webm': 'video/webm',
+  '.webp': 'image/webp',
+  '.avif': 'image/avif',
+  '.mjs': 'application/javascript',
+  '.jsx': 'text/jsx',
+  '.ts': 'application/typescript',
+  '.tsx': 'text/tsx',
+  '.md': 'text/markdown',
+  '.yaml': 'text/yaml',
+  '.yml': 'text/yaml',
+  '.rtf': 'application/rtf',
+  '.doc': 'application/msword',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.xls': 'application/vnd.ms-excel',
+  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  '.ppt': 'application/vnd.ms-powerpoint',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+};
+
+/**
+ * Obtiene el tipo MIME para una extensión de archivo
+ * @param {string} filename - Nombre del archivo
+ * @returns {string} - Tipo MIME correspondiente
+ */
+function getMimeType(filename) {
+  const extension = '.' + filename.split('.').pop().toLowerCase();
+  return mimeTypes[extension] || 'application/octet-stream';
+}
+
+module.exports = {
+  getMimeType
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jerkjs",
-  "version": "2.1.7",
-  "description": "JERK Framework v2.1 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, and template engine with performance optimizations",
+  "version": "2.2.0",
+  "description": "JERK Framework v2.2 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, and template engine with performance optimizations and complete MVC architecture with models",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -24,7 +24,9 @@
     "waf",
     "performance",
     "optimized",
-    "hooked"
+    "hooked",
+    "mvc",
+    "models"
   ],
   "author": "JERK Framework Team / Benjamin Sanhez Cardenas",
   "license": "Apache-2.0",

package/BUG_REPORTE_COMPRESION.txt

@@ -1,72 +0,0 @@
-# Reporte de Bug: Falta de Header Content-Encoding en Respuestas Comprimidas
-
-## Descripción del Problema
-
-El middleware de compresión del framework JERK no estaba enviando el header `Content-Encoding: gzip` (o `Content-Encoding: deflate`) cuando se comprimían las respuestas. Esto causaba que los navegadores y clientes HTTP no pudieran descomprimir automáticamente las respuestas comprimidas, resultando en contenido ilegible para el usuario final.
-
-## Causa Raíz
-
-El problema se producía porque los controladores en el framework JERK llamaban directamente a `res.writeHead()` antes de que el middleware de compresión tuviera la oportunidad de modificar los headers. Cuando un controlador llama a `res.writeHead()`, los encabezados se envían inmediatamente al cliente, y una vez enviados, no se pueden modificar posteriormente.
-
-En el código del controlador de ejemplo:
-```javascript
-res.writeHead(200, { 'Content-Type': 'application/json' });
-res.end(JSON.stringify(largeData));
-```
-
-La llamada a `writeHead` se ejecutaba antes de que el middleware de compresión pudiera agregar el header `Content-Encoding`.
-
-## Solución Implementada
-
-Se modificó el middleware de compresión (`lib/middleware/compressor.js`) para implementar un sistema de captura y posposición de encabezados:
-
-### 1. Interceptación de writeHead
-Se sobreescribió el método `res.writeHead()` para capturar los encabezados originales pero no enviarlos inmediatamente:
-
-```javascript
-res.writeHead = (code, headers) => {
-  statusCode = code;
-  if (typeof headers === 'object' && headers !== null) {
-    responseHeaders = { ...headers };
-  }
-  
-  // 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;
-};
-```
-
-### 2. Envío Condicionado de Encabezados
-Cuando se determina si se debe comprimir la respuesta, se combinan los encabezados originales con el header `Content-Encoding` y se envían juntos:
-
-```javascript
-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);
-}
-```
-
-## Resultado
-
-Después de la corrección:
-- Las respuestas comprimidas ahora incluyen correctamente el header `Content-Encoding: gzip`
-- Los navegadores pueden descomprimir automáticamente las respuestas
-- El contenido se muestra correctamente al usuario
-- Se mantiene la compatibilidad con los controladores existentes
-
-## Archivos Modificados
-
-- `lib/middleware/compressor.js`: Implementación de la solución
-
-## Pruebas Realizadas
-
-- Se verificó que el header `Content-Encoding: gzip` aparece en las respuestas cuando se solicita compresión
-- Se confirmó que la respuesta se puede descomprimir correctamente usando herramientas como `zcat`
-- Se probó con múltiples endpoints para asegurar la consistencia del comportamiento